Merge #1545

1545: migrate ra_syntax to the new rowan API r=matklad a=matklad Co-authored-by: Aleksey Kladov <[email protected]>
author: bors[bot] <26634292+bors[bot]@users.noreply.github.com> 2019-07-19 12:15:55 +0100
committer: bors[bot] <26634292+bors[bot]@users.noreply.github.com> 2019-07-19 12:15:55 +0100
commit: f209843e31af7f0e0212aa28ffec2efad2a70c6f (patch)
tree: 548227da78a3bea644f57714d075410c0bdf7469 /crates
parent: 58d4983ba5745975446d60f2886d96f8d2adf0f2 (diff)
parent: d4a66166c002f0a49e41d856a49cb5685ac93202 (diff)
91 files changed, 1980 insertions, 3096 deletions
diff --git a/crates/ra_assists/src/add_derive.rs b/crates/ra_assists/src/add_derive.rs
index bf7d55d6d..f19196f53 100644
--- a/crates/ra_assists/src/add_derive.rs
+++ b/crates/ra_assists/src/add_derive.rs
@@ -9,7 +9,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_derive(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
-    let node_start = derive_insertion_offset(nominal)?;
+    let node_start = derive_insertion_offset(&nominal)?;
    ctx.add_action(AssistId("add_derive"), "add `#[derive]`", |edit| {
        let derive_attr = nominal
            .attrs()
diff --git a/crates/ra_assists/src/add_explicit_type.rs b/crates/ra_assists/src/add_explicit_type.rs
index bb47a32f0..a69cfc8e3 100644
--- a/crates/ra_assists/src/add_explicit_type.rs
+++ b/crates/ra_assists/src/add_explicit_type.rs
@@ -27,7 +27,7 @@ pub(crate) fn add_explicit_type(mut ctx: AssistCtx<impl HirDatabase>) -> Option<
    // Infer type
    let db = ctx.db;
    let analyzer = hir::SourceAnalyzer::new(db, ctx.frange.file_id, stmt.syntax(), None);
-    let ty = analyzer.type_of(db, expr)?;
+    let ty = analyzer.type_of(db, &expr)?;
    // Assist not applicable if the type is unknown
    if is_unknown(&ty) {
        return None;
diff --git a/crates/ra_assists/src/add_impl.rs b/crates/ra_assists/src/add_impl.rs
index b81922c1d..cebc19539 100644
--- a/crates/ra_assists/src/add_impl.rs
+++ b/crates/ra_assists/src/add_impl.rs
@@ -16,7 +16,7 @@ pub(crate) fn add_impl(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        let start_offset = nominal.syntax().range().end();
        let mut buf = String::new();
        buf.push_str("\n\nimpl");
-        if let Some(type_params) = type_params {
+        if let Some(type_params) = &type_params {
            type_params.syntax().text().push_to(&mut buf);
        }
        buf.push_str(" ");
@@ -25,9 +25,9 @@ pub(crate) fn add_impl(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
            let lifetime_params = type_params
                .lifetime_params()
                .filter_map(|it| it.lifetime_token())
-                .map(|it| it.text());
+                .map(|it| it.text().clone());
            let type_params =
-                type_params.type_params().filter_map(|it| it.name()).map(|it| it.text());
+                type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
            join(lifetime_params.chain(type_params)).surround_with("<", ">").to_buf(&mut buf);
        }
        buf.push_str(" {\n");
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index 6ffdad0b1..b992a4dc8 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -5,8 +5,8 @@ use crate::{
 use hir::{db::HirDatabase, HasSource};
 use ra_db::FilePosition;
-use ra_syntax::ast::{self, AstNode, ImplItem, ImplItemKind, NameOwner};
+use ra_syntax::ast::{self, AstNode, ImplItemKind, NameOwner};
-use ra_syntax::{SmolStr, TreeArc};
+use ra_syntax::SmolStr;
 #[derive(PartialEq)]
 enum AddMissingImplMembersMode {
@@ -46,16 +46,16 @@ fn add_missing_impl_members_inner(
        let position = FilePosition { file_id, offset: impl_node.syntax().range().start() };
        let analyzer = hir::SourceAnalyzer::new(ctx.db, position.file_id, impl_node.syntax(), None);
-        resolve_target_trait_def(ctx.db, &analyzer, impl_node)?
+        resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
    };
-    let def_name = |kind| -> Option<&SmolStr> {
+    let def_name = |kind| -> Option<SmolStr> {
        match kind {
-            ImplItemKind::FnDef(def) => def.name(),
+            ast::ImplItemKind::FnDef(def) => def.name(),
-            ImplItemKind::TypeAliasDef(def) => def.name(),
+            ast::ImplItemKind::TypeAliasDef(def) => def.name(),
-            ImplItemKind::ConstDef(def) => def.name(),
+            ast::ImplItemKind::ConstDef(def) => def.name(),
        }
-        .map(ast::Name::text)
+        .map(|it| it.text().clone())
    };
    let trait_items = trait_def.item_list()?.impl_items();
@@ -78,18 +78,13 @@ fn add_missing_impl_members_inner(
    ctx.add_action(AssistId(assist_id), label, |edit| {
        let n_existing_items = impl_item_list.impl_items().count();
-        let items: Vec<_> = missing_items
+        let items = missing_items.into_iter().map(|it| match it.kind() {
-            .into_iter()
+            ImplItemKind::FnDef(def) => strip_docstring(add_body(def).into()),
-            .map(|it| match it.kind() {
+            _ => strip_docstring(it),
-                ImplItemKind::FnDef(def) => {
+        });
-                    strip_docstring(ImplItem::cast(add_body(def).syntax()).unwrap())
-                }
-                _ => strip_docstring(it),
-            })
-            .collect();
        let mut ast_editor = AstEditor::new(impl_item_list);
-        ast_editor.append_items(items.iter().map(|it| &**it));
+        ast_editor.append_items(items);
        let first_new_item = ast_editor.ast().impl_items().nth(n_existing_items).unwrap();
        let cursor_position = first_new_item.syntax().range().start();
@@ -101,14 +96,14 @@ fn add_missing_impl_members_inner(
    ctx.build()
 }
-fn strip_docstring(item: &ast::ImplItem) -> TreeArc<ast::ImplItem> {
+fn strip_docstring(item: ast::ImplItem) -> ast::ImplItem {
    let mut ast_editor = AstEditor::new(item);
    ast_editor.strip_attrs_and_docs();
    ast_editor.ast().to_owned()
 }
-fn add_body(fn_def: &ast::FnDef) -> TreeArc<ast::FnDef> {
+fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
-    let mut ast_editor = AstEditor::new(fn_def);
+    let mut ast_editor = AstEditor::new(fn_def.clone());
    if fn_def.body().is_none() {
        ast_editor.set_body(&AstBuilder::<ast::Block>::single_expr(
            &AstBuilder::<ast::Expr>::unimplemented(),
@@ -123,9 +118,12 @@ fn resolve_target_trait_def(
    db: &impl HirDatabase,
    analyzer: &hir::SourceAnalyzer,
    impl_block: &ast::ImplBlock,
-) -> Option<TreeArc<ast::TraitDef>> {
+) -> Option<ast::TraitDef> {
-    let ast_path =
+    let ast_path = impl_block
-        impl_block.target_trait().map(AstNode::syntax).and_then(ast::PathType::cast)?.path()?;
+        .target_trait()
+        .map(|it| it.syntax().clone())
+        .and_then(ast::PathType::cast)?
+        .path()?;
    match analyzer.resolve_path(db, &ast_path) {
        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).ast),
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 34b207154..e52085f85 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -49,7 +49,7 @@ pub(crate) enum Assist {
 pub(crate) struct AssistCtx<'a, DB> {
    pub(crate) db: &'a DB,
    pub(crate) frange: FileRange,
-    source_file: &'a SourceFile,
+    source_file: SourceFile,
    should_compute_edit: bool,
    assist: Assist,
 }
@@ -59,7 +59,7 @@ impl<'a, DB> Clone for AssistCtx<'a, DB> {
        AssistCtx {
            db: self.db,
            frange: self.frange,
-            source_file: self.source_file,
+            source_file: self.source_file.clone(),
            should_compute_edit: self.should_compute_edit,
            assist: self.assist.clone(),
        }
@@ -104,18 +104,18 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
        Some(self.assist)
    }
-    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken<'a>> {
+    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
        find_token_at_offset(self.source_file.syntax(), self.frange.range.start())
    }
-    pub(crate) fn node_at_offset<N: AstNode>(&self) -> Option<&'a N> {
+    pub(crate) fn node_at_offset<N: AstNode>(&self) -> Option<N> {
        find_node_at_offset(self.source_file.syntax(), self.frange.range.start())
    }
-    pub(crate) fn covering_element(&self) -> SyntaxElement<'a> {
+    pub(crate) fn covering_element(&self) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), self.frange.range)
    }
-    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement<'a> {
+    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), range)
    }
 }
@@ -139,7 +139,7 @@ impl AssistBuilder {
    ) {
        let mut replace_with = replace_with.into();
        if let Some(indent) = leading_indent(node) {
-            replace_with = reindent(&replace_with, indent)
+            replace_with = reindent(&replace_with, &indent)
        }
        self.replace(node.range(), replace_with)
    }
diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
index 7b743c9f0..5fbcadfee 100644
--- a/crates/ra_assists/src/ast_editor.rs
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -4,18 +4,18 @@ use arrayvec::ArrayVec;
 use hir::Name;
 use ra_fmt::leading_indent;
 use ra_syntax::{
-    ast, AstNode, Direction, InsertPosition, SourceFile, SyntaxElement, SyntaxKind::*, TreeArc, T,
+    ast, AstNode, Direction, InsertPosition, SourceFile, SyntaxElement, SyntaxKind::*, T,
 };
 use ra_text_edit::TextEditBuilder;
 pub struct AstEditor<N: AstNode> {
-    original_ast: TreeArc<N>,
+    original_ast: N,
-    ast: TreeArc<N>,
+    ast: N,
 }
 impl<N: AstNode> AstEditor<N> {
-    pub fn new(node: &N) -> AstEditor<N> {
+    pub fn new(node: N) -> AstEditor<N> {
-        AstEditor { original_ast: node.to_owned(), ast: node.to_owned() }
+        AstEditor { original_ast: node.clone(), ast: node }
    }
    pub fn into_text_edit(self, builder: &mut TextEditBuilder) {
@@ -26,27 +26,27 @@ impl<N: AstNode> AstEditor<N> {
    }
    pub fn ast(&self) -> &N {
-        &*self.ast
+        &self.ast
    }
    #[must_use]
-    fn insert_children<'a>(
+    fn insert_children(
        &self,
-        position: InsertPosition<SyntaxElement<'_>>,
+        position: InsertPosition<SyntaxElement>,
-        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+        to_insert: impl Iterator<Item = SyntaxElement>,
-    ) -> TreeArc<N> {
+    ) -> N {
        let new_syntax = self.ast().syntax().insert_children(position, to_insert);
-        N::cast(&new_syntax).unwrap().to_owned()
+        N::cast(new_syntax).unwrap()
    }
    #[must_use]
-    fn replace_children<'a>(
+    fn replace_children(
        &self,
-        to_delete: RangeInclusive<SyntaxElement<'_>>,
+        to_delete: RangeInclusive<SyntaxElement>,
-        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+        to_insert: impl Iterator<Item = SyntaxElement>,
-    ) -> TreeArc<N> {
+    ) -> N {
        let new_syntax = self.ast().syntax().replace_children(to_delete, to_insert);
-        N::cast(&new_syntax).unwrap().to_owned()
+        N::cast(new_syntax).unwrap()
    }
    fn do_make_multiline(&mut self) {
@@ -66,16 +66,18 @@ impl<N: AstNode> AstEditor<N> {
                if ws.text().contains('\n') {
                    return;
                }
-                Some(ws)
+                Some(ws.clone())
            }
        };
-        let indent = leading_indent(self.ast().syntax()).unwrap_or("");
+        let indent = leading_indent(self.ast().syntax()).unwrap_or("".into());
        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
        let to_insert = iter::once(ws.ws().into());
        self.ast = match existing_ws {
            None => self.insert_children(InsertPosition::After(l_curly), to_insert),
-            Some(ws) => self.replace_children(RangeInclusive::new(ws.into(), ws.into()), to_insert),
+            Some(ws) => {
+                self.replace_children(RangeInclusive::new(ws.clone().into(), ws.into()), to_insert)
+            }
        };
    }
 }
@@ -95,7 +97,7 @@ impl AstEditor<ast::NamedFieldList> {
        let space = if is_multiline {
            ws = tokens::WsBuilder::new(&format!(
                "\n{}    ",
-                leading_indent(self.ast().syntax()).unwrap_or("")
+                leading_indent(self.ast().syntax()).unwrap_or("".into())
            ));
            ws.ws()
        } else {
@@ -104,7 +106,7 @@ impl AstEditor<ast::NamedFieldList> {
        let mut to_insert: ArrayVec<[SyntaxElement; 4]> = ArrayVec::new();
        to_insert.push(space.into());
-        to_insert.push(field.syntax().into());
+        to_insert.push(field.syntax().clone().into());
        to_insert.push(tokens::comma().into());
        macro_rules! after_l_curly {
@@ -127,7 +129,7 @@ impl AstEditor<ast::NamedFieldList> {
                    InsertPosition::After(comma)
                } else {
                    to_insert.insert(0, tokens::comma().into());
-                    InsertPosition::After($anchor.syntax().into())
+                    InsertPosition::After($anchor.syntax().clone().into())
                }
            };
        };
@@ -144,7 +146,9 @@ impl AstEditor<ast::NamedFieldList> {
                    None => after_l_curly!(),
                }
            }
-            InsertPosition::Before(anchor) => InsertPosition::Before(anchor.syntax().into()),
+            InsertPosition::Before(anchor) => {
+                InsertPosition::Before(anchor.syntax().clone().into())
+            }
            InsertPosition::After(anchor) => after_field!(anchor),
        };
@@ -157,7 +161,7 @@ impl AstEditor<ast::NamedFieldList> {
 }
 impl AstEditor<ast::ItemList> {
-    pub fn append_items<'a>(&mut self, items: impl Iterator<Item = &'a ast::ImplItem>) {
+    pub fn append_items(&mut self, items: impl Iterator<Item = ast::ImplItem>) {
        let n_existing_items = self.ast().impl_items().count();
        if n_existing_items == 0 {
            self.do_make_multiline();
@@ -165,22 +169,23 @@ impl AstEditor<ast::ItemList> {
        items.for_each(|it| self.append_item(it));
    }
-    pub fn append_item(&mut self, item: &ast::ImplItem) {
+    pub fn append_item(&mut self, item: ast::ImplItem) {
        let (indent, position) = match self.ast().impl_items().last() {
            Some(it) => (
-                leading_indent(it.syntax()).unwrap_or("").to_string(),
+                leading_indent(it.syntax()).unwrap_or_default().to_string(),
-                InsertPosition::After(it.syntax().into()),
+                InsertPosition::After(it.syntax().clone().into()),
            ),
            None => match self.l_curly() {
                Some(it) => (
-                    "    ".to_string() + leading_indent(self.ast().syntax()).unwrap_or(""),
+                    "    ".to_string() + &leading_indent(self.ast().syntax()).unwrap_or_default(),
                    InsertPosition::After(it),
                ),
                None => return,
            },
        };
        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
-        let to_insert: ArrayVec<[SyntaxElement; 2]> = [ws.ws().into(), item.syntax().into()].into();
+        let to_insert: ArrayVec<[SyntaxElement; 2]> =
+            [ws.ws().into(), item.syntax().clone().into()].into();
        self.ast = self.insert_children(position, to_insert.into_iter());
    }
@@ -197,9 +202,9 @@ impl AstEditor<ast::ImplItem> {
            .children_with_tokens()
            .find(|it| it.kind() == ATTR || it.kind() == COMMENT)
        {
-            let end = match start.next_sibling_or_token() {
+            let end = match &start.next_sibling_or_token() {
-                Some(el) if el.kind() == WHITESPACE => el,
+                Some(el) if el.kind() == WHITESPACE => el.clone(),
-                Some(_) | None => start,
+                Some(_) | None => start.clone(),
            };
            self.ast = self.replace_children(RangeInclusive::new(start, end), iter::empty());
        }
@@ -210,18 +215,18 @@ impl AstEditor<ast::FnDef> {
    pub fn set_body(&mut self, body: &ast::Block) {
        let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
        let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.ast().body() {
-            old_body.syntax().into()
+            old_body.syntax().clone().into()
        } else if let Some(semi) = self.ast().semicolon_token() {
            to_insert.push(tokens::single_space().into());
            semi.into()
        } else {
            to_insert.push(tokens::single_space().into());
-            to_insert.push(body.syntax().into());
+            to_insert.push(body.syntax().clone().into());
            self.ast = self.insert_children(InsertPosition::Last, to_insert.into_iter());
            return;
        };
-        to_insert.push(body.syntax().into());
+        to_insert.push(body.syntax().clone().into());
-        let replace_range = RangeInclusive::new(old_body_or_semi, old_body_or_semi);
+        let replace_range = RangeInclusive::new(old_body_or_semi.clone(), old_body_or_semi);
        self.ast = self.replace_children(replace_range, to_insert.into_iter())
    }
 }
@@ -231,15 +236,15 @@ pub struct AstBuilder<N: AstNode> {
 }
 impl AstBuilder<ast::NamedField> {
-    pub fn from_name(name: &Name) -> TreeArc<ast::NamedField> {
+    pub fn from_name(name: &Name) -> ast::NamedField {
        ast_node_from_file_text(&format!("fn f() {{ S {{ {}: (), }} }}", name))
    }
-    fn from_text(text: &str) -> TreeArc<ast::NamedField> {
+    fn from_text(text: &str) -> ast::NamedField {
        ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
    }
-    pub fn from_pieces(name: &ast::NameRef, expr: Option<&ast::Expr>) -> TreeArc<ast::NamedField> {
+    pub fn from_pieces(name: &ast::NameRef, expr: Option<&ast::Expr>) -> ast::NamedField {
        match expr {
            Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
            None => Self::from_text(&name.syntax().to_string()),
@@ -248,36 +253,36 @@ impl AstBuilder<ast::NamedField> {
 }
 impl AstBuilder<ast::Block> {
-    fn from_text(text: &str) -> TreeArc<ast::Block> {
+    fn from_text(text: &str) -> ast::Block {
        ast_node_from_file_text(&format!("fn f() {}", text))
    }
-    pub fn single_expr(e: &ast::Expr) -> TreeArc<ast::Block> {
+    pub fn single_expr(e: &ast::Expr) -> ast::Block {
        Self::from_text(&format!("{{ {} }}", e.syntax()))
    }
 }
 impl AstBuilder<ast::Expr> {
-    fn from_text(text: &str) -> TreeArc<ast::Expr> {
+    fn from_text(text: &str) -> ast::Expr {
        ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
    }
-    pub fn unit() -> TreeArc<ast::Expr> {
+    pub fn unit() -> ast::Expr {
        Self::from_text("()")
    }
-    pub fn unimplemented() -> TreeArc<ast::Expr> {
+    pub fn unimplemented() -> ast::Expr {
        Self::from_text("unimplemented!()")
    }
 }
 impl AstBuilder<ast::NameRef> {
-    pub fn new(text: &str) -> TreeArc<ast::NameRef> {
+    pub fn new(text: &str) -> ast::NameRef {
        ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
    }
 }
-fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
+fn ast_node_from_file_text<N: AstNode>(text: &str) -> N {
    let parse = SourceFile::parse(text);
    let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap().to_owned();
    res
@@ -285,47 +290,49 @@ fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
 mod tokens {
    use once_cell::sync::Lazy;
-    use ra_syntax::{AstNode, SourceFile, SyntaxKind::*, SyntaxToken, TreeArc, T};
+    use ra_syntax::{AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken, T};
-    static SOURCE_FILE: Lazy<TreeArc<SourceFile>> =
+    static SOURCE_FILE: Lazy<Parse<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;"));
-        Lazy::new(|| SourceFile::parse(",\n; ;").tree().to_owned());
-    pub(crate) fn comma() -> SyntaxToken<'static> {
+    pub(crate) fn comma() -> SyntaxToken {
        SOURCE_FILE
+            .tree()
            .syntax()
            .descendants_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == T![,])
            .unwrap()
    }
-    pub(crate) fn single_space() -> SyntaxToken<'static> {
+    pub(crate) fn single_space() -> SyntaxToken {
        SOURCE_FILE
+            .tree()
            .syntax()
            .descendants_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == " ")
            .unwrap()
    }
    #[allow(unused)]
-    pub(crate) fn single_newline() -> SyntaxToken<'static> {
+    pub(crate) fn single_newline() -> SyntaxToken {
        SOURCE_FILE
+            .tree()
            .syntax()
            .descendants_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n")
            .unwrap()
    }
-    pub(crate) struct WsBuilder(TreeArc<SourceFile>);
+    pub(crate) struct WsBuilder(SourceFile);
    impl WsBuilder {
        pub(crate) fn new(text: &str) -> WsBuilder {
            WsBuilder(SourceFile::parse(text).ok().unwrap())
        }
-        pub(crate) fn ws(&self) -> SyntaxToken<'_> {
+        pub(crate) fn ws(&self) -> SyntaxToken {
-            self.0.syntax().first_child_or_token().unwrap().as_token().unwrap()
+            self.0.syntax().first_child_or_token().unwrap().as_token().cloned().unwrap()
        }
    }
diff --git a/crates/ra_assists/src/auto_import.rs b/crates/ra_assists/src/auto_import.rs
index f8f37e852..0eb4bdb62 100644
--- a/crates/ra_assists/src/auto_import.rs
+++ b/crates/ra_assists/src/auto_import.rs
@@ -12,25 +12,25 @@ use ra_syntax::{
    SyntaxNode, TextRange, T,
 };
-fn collect_path_segments_raw<'a>(
+fn collect_path_segments_raw(
-    segments: &mut Vec<&'a ast::PathSegment>,
+    segments: &mut Vec<ast::PathSegment>,
-    mut path: &'a ast::Path,
+    mut path: ast::Path,
 ) -> Option<usize> {
    let oldlen = segments.len();
    loop {
        let mut children = path.syntax().children_with_tokens();
        let (first, second, third) = (
-            children.next().map(|n| (n, n.kind())),
+            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n, n.kind())),
+            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n, n.kind())),
+            children.next().map(|n| (n.clone(), n.kind())),
        );
        match (first, second, third) {
            (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
-                path = ast::Path::cast(subpath.as_node()?)?;
+                path = ast::Path::cast(subpath.as_node()?.clone())?;
-                segments.push(ast::PathSegment::cast(segment.as_node()?)?);
+                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
            }
            (Some((segment, PATH_SEGMENT)), _, _) => {
-                segments.push(ast::PathSegment::cast(segment.as_node()?)?);
+                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
                break;
            }
            (_, _, _) => return None,
@@ -60,7 +60,7 @@ fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
 }
 // Returns the numeber of common segments.
-fn compare_path_segments(left: &[SmolStr], right: &[&ast::PathSegment]) -> usize {
+fn compare_path_segments(left: &[SmolStr], right: &[ast::PathSegment]) -> usize {
    left.iter().zip(right).filter(|(l, r)| compare_path_segment(l, r)).count()
 }
@@ -81,12 +81,12 @@ fn compare_path_segment_with_name(a: &SmolStr, b: &ast::Name) -> bool {
    a == b.text()
 }
-#[derive(Copy, Clone)]
+#[derive(Clone)]
-enum ImportAction<'a> {
+enum ImportAction {
    Nothing,
    // Add a brand new use statement.
    AddNewUse {
-        anchor: Option<&'a SyntaxNode>, // anchor node
+        anchor: Option<SyntaxNode>, // anchor node
        add_after_anchor: bool,
    },
@@ -94,9 +94,9 @@ enum ImportAction<'a> {
    AddNestedImport {
        // how may segments matched with the target path
        common_segments: usize,
-        path_to_split: &'a ast::Path,
+        path_to_split: ast::Path,
        // the first segment of path_to_split we want to add into the new nested list
-        first_segment_to_split: Option<&'a ast::PathSegment>,
+        first_segment_to_split: Option<ast::PathSegment>,
        // Wether to add 'self' in addition to the target path
        add_self: bool,
    },
@@ -104,20 +104,20 @@ enum ImportAction<'a> {
    AddInTreeList {
        common_segments: usize,
        // The UseTreeList where to add the target path
-        tree_list: &'a ast::UseTreeList,
+        tree_list: ast::UseTreeList,
        add_self: bool,
    },
 }
-impl<'a> ImportAction<'a> {
+impl ImportAction {
-    fn add_new_use(anchor: Option<&'a SyntaxNode>, add_after_anchor: bool) -> Self {
+    fn add_new_use(anchor: Option<SyntaxNode>, add_after_anchor: bool) -> Self {
        ImportAction::AddNewUse { anchor, add_after_anchor }
    }
    fn add_nested_import(
        common_segments: usize,
-        path_to_split: &'a ast::Path,
+        path_to_split: ast::Path,
-        first_segment_to_split: Option<&'a ast::PathSegment>,
+        first_segment_to_split: Option<ast::PathSegment>,
        add_self: bool,
    ) -> Self {
        ImportAction::AddNestedImport {
@@ -130,14 +130,14 @@ impl<'a> ImportAction<'a> {
    fn add_in_tree_list(
        common_segments: usize,
-        tree_list: &'a ast::UseTreeList,
+        tree_list: ast::UseTreeList,
        add_self: bool,
    ) -> Self {
        ImportAction::AddInTreeList { common_segments, tree_list, add_self }
    }
-    fn better<'b>(left: &'b ImportAction<'a>, right: &'b ImportAction<'a>) -> &'b ImportAction<'a> {
+    fn better(left: ImportAction, right: ImportAction) -> ImportAction {
-        if left.is_better(right) {
+        if left.is_better(&right) {
            left
        } else {
            right
@@ -166,12 +166,12 @@ impl<'a> ImportAction<'a> {
 // Find out the best ImportAction to import target path against current_use_tree.
 // If current_use_tree has a nested import the function gets called recursively on every UseTree inside a UseTreeList.
-fn walk_use_tree_for_best_action<'a>(
+fn walk_use_tree_for_best_action(
-    current_path_segments: &mut Vec<&'a ast::PathSegment>, // buffer containing path segments
+    current_path_segments: &mut Vec<ast::PathSegment>, // buffer containing path segments
-    current_parent_use_tree_list: Option<&'a ast::UseTreeList>, // will be Some value if we are in a nested import
+    current_parent_use_tree_list: Option<ast::UseTreeList>, // will be Some value if we are in a nested import
-    current_use_tree: &'a ast::UseTree, // the use tree we are currently examinating
+    current_use_tree: ast::UseTree, // the use tree we are currently examinating
-    target: &[SmolStr],                 // the path we want to import
+    target: &[SmolStr],             // the path we want to import
-) -> ImportAction<'a> {
+) -> ImportAction {
    // We save the number of segments in the buffer so we can restore the correct segments
    // before returning. Recursive call will add segments so we need to delete them.
    let prev_len = current_path_segments.len();
@@ -188,32 +188,36 @@ fn walk_use_tree_for_best_action<'a>(
                    .syntax()
                    .ancestors()
                    .find_map(ast::UseItem::cast)
-                    .map(AstNode::syntax),
+                    .map(|it| it.syntax().clone()),
                true,
            );
        }
    };
    // This can happen only if current_use_tree is a direct child of a UseItem
-    if let Some(name) = alias.and_then(ast::NameOwner::name) {
+    if let Some(name) = alias.and_then(|it| it.name()) {
-        if compare_path_segment_with_name(&target[0], name) {
+        if compare_path_segment_with_name(&target[0], &name) {
            return ImportAction::Nothing;
        }
    }
-    collect_path_segments_raw(current_path_segments, path);
+    collect_path_segments_raw(current_path_segments, path.clone());
    // We compare only the new segments added in the line just above.
    // The first prev_len segments were already compared in 'parent' recursive calls.
    let left = target.split_at(prev_len).1;
    let right = current_path_segments.split_at(prev_len).1;
-    let common = compare_path_segments(left, right);
+    let common = compare_path_segments(left, &right);
    let mut action = match common {
        0 => ImportAction::add_new_use(
            // e.g: target is std::fmt and we can have
            // use foo::bar
            // We add a brand new use statement
-            current_use_tree.syntax().ancestors().find_map(ast::UseItem::cast).map(AstNode::syntax),
+            current_use_tree
+                .syntax()
+                .ancestors()
+                .find_map(ast::UseItem::cast)
+                .map(|it| it.syntax().clone()),
            true,
        ),
        common if common == left.len() && left.len() == right.len() => {
@@ -223,9 +227,9 @@ fn walk_use_tree_for_best_action<'a>(
            if let Some(list) = tree_list {
                // In case 2 we need to add self to the nested list
                // unless it's already there
-                let has_self = list.use_trees().map(ast::UseTree::path).any(|p| {
+                let has_self = list.use_trees().map(|it| it.path()).any(|p| {
-                    p.and_then(ast::Path::segment)
+                    p.and_then(|it| it.segment())
-                        .and_then(ast::PathSegment::kind)
+                        .and_then(|it| it.kind())
                        .filter(|k| *k == ast::PathSegmentKind::SelfKw)
                        .is_some()
                });
@@ -248,7 +252,7 @@ fn walk_use_tree_for_best_action<'a>(
            ImportAction::add_nested_import(
                prev_len + common,
                path,
-                Some(segments_to_split[0]),
+                Some(segments_to_split[0].clone()),
                false,
            )
        }
@@ -263,14 +267,18 @@ fn walk_use_tree_for_best_action<'a>(
                    .syntax()
                    .ancestors()
                    .find_map(ast::UseItem::cast)
-                    .map(AstNode::syntax),
+                    .map(|it| it.syntax().clone()),
                true,
            );
            if let Some(list) = tree_list {
                // Case 2, check recursively if the path is already imported in the nested list
                for u in list.use_trees() {
-                    let child_action =
+                    let child_action = walk_use_tree_for_best_action(
-                        walk_use_tree_for_best_action(current_path_segments, Some(list), u, target);
+                        current_path_segments,
+                        Some(list.clone()),
+                        u,
+                        target,
+                    );
                    if child_action.is_better(&better_action) {
                        better_action = child_action;
                        if let ImportAction::Nothing = better_action {
@@ -291,7 +299,7 @@ fn walk_use_tree_for_best_action<'a>(
            ImportAction::add_nested_import(
                prev_len + common,
                path,
-                Some(segments_to_split[0]),
+                Some(segments_to_split[0].clone()),
                true,
            )
        }
@@ -302,7 +310,7 @@ fn walk_use_tree_for_best_action<'a>(
            ImportAction::add_nested_import(
                prev_len + common,
                path,
-                Some(segments_to_split[0]),
+                Some(segments_to_split[0].clone()),
                false,
            )
        }
@@ -311,7 +319,7 @@ fn walk_use_tree_for_best_action<'a>(
    // If we are inside a UseTreeList adding a use statement become adding to the existing
    // tree list.
-    action = match (current_parent_use_tree_list, action) {
+    action = match (current_parent_use_tree_list, action.clone()) {
        (Some(use_tree_list), ImportAction::AddNewUse { .. }) => {
            ImportAction::add_in_tree_list(prev_len, use_tree_list, false)
        }
@@ -323,19 +331,20 @@ fn walk_use_tree_for_best_action<'a>(
    action
 }
-fn best_action_for_target<'b, 'a: 'b>(
+fn best_action_for_target(
-    container: &'a SyntaxNode,
+    container: SyntaxNode,
-    anchor: &'a SyntaxNode,
+    anchor: SyntaxNode,
-    target: &'b [SmolStr],
+    target: &[SmolStr],
-) -> ImportAction<'a> {
+) -> ImportAction {
    let mut storage = Vec::with_capacity(16); // this should be the only allocation
    let best_action = container
        .children()
        .filter_map(ast::UseItem::cast)
-        .filter_map(ast::UseItem::use_tree)
+        .filter_map(|it| it.use_tree())
        .map(|u| walk_use_tree_for_best_action(&mut storage, None, u, target))
-        .fold(None, |best, a| {
+        .fold(None, |best, a| match best {
-            best.and_then(|best| Some(*ImportAction::better(&best, &a))).or_else(|| Some(a))
+            Some(best) => Some(ImportAction::better(best, a)),
+            None => Some(a),
        });
    match best_action {
@@ -386,7 +395,7 @@ fn make_assist(action: &ImportAction, target: &[SmolStr], edit: &mut TextEditBui
 }
 fn make_assist_add_new_use(
-    anchor: &Option<&SyntaxNode>,
+    anchor: &Option<SyntaxNode>,
    after: bool,
    target: &[SmolStr],
    edit: &mut TextEditBuilder,
@@ -396,7 +405,7 @@ fn make_assist_add_new_use(
        let mut buf = String::new();
        if after {
            buf.push_str("\n");
-            if let Some(spaces) = indent {
+            if let Some(spaces) = &indent {
                buf.push_str(spaces);
            }
        }
@@ -405,8 +414,8 @@ fn make_assist_add_new_use(
        buf.push_str(";");
        if !after {
            buf.push_str("\n\n");
-            if let Some(spaces) = indent {
+            if let Some(spaces) = &indent {
-                buf.push_str(spaces);
+                buf.push_str(&spaces);
            }
        }
        let position = if after { anchor.range().end() } else { anchor.range().start() };
@@ -444,7 +453,7 @@ fn make_assist_add_in_tree_list(
 fn make_assist_add_nested_import(
    path: &ast::Path,
-    first_segment_to_split: &Option<&ast::PathSegment>,
+    first_segment_to_split: &Option<ast::PathSegment>,
    target: &[SmolStr],
    add_self: bool,
    edit: &mut TextEditBuilder,
@@ -482,7 +491,7 @@ fn apply_auto_import(
    target: &[SmolStr],
    edit: &mut TextEditBuilder,
 ) {
-    let action = best_action_for_target(container, path.syntax(), target);
+    let action = best_action_for_target(container.clone(), path.syntax().clone(), target);
    make_assist(&action, target, edit);
    if let Some(last) = path.segment() {
        // Here we are assuming the assist will provide a  correct use statement
@@ -522,26 +531,26 @@ pub fn auto_import_text_edit(
    edit: &mut TextEditBuilder,
 ) {
    let container = position.ancestors().find_map(|n| {
-        if let Some(module) = ast::Module::cast(n) {
+        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(ast::AstNode::syntax);
+            return module.item_list().map(|it| it.syntax().clone());
        }
-        ast::SourceFile::cast(n).map(ast::AstNode::syntax)
+        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
    });
    if let Some(container) = container {
-        let action = best_action_for_target(container, anchor, target);
+        let action = best_action_for_target(container, anchor.clone(), target);
        make_assist(&action, target, edit);
    }
 }
 pub(crate) fn auto_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let path: &ast::Path = ctx.node_at_offset()?;
+    let path: ast::Path = ctx.node_at_offset()?;
    // We don't want to mess with use statements
    if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
        return None;
    }
-    let hir_path = hir::Path::from_ast(path)?;
+    let hir_path = hir::Path::from_ast(path.clone())?;
    let segments = collect_hir_path_segments(&hir_path);
    if segments.len() < 2 {
        return None;
@@ -554,7 +563,7 @@ pub(crate) fn auto_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
                format!("import {} in mod {}", fmt_segments(&segments), name.text()),
                |edit| {
                    let mut text_edit = TextEditBuilder::default();
-                    apply_auto_import(item_list.syntax(), path, &segments, &mut text_edit);
+                    apply_auto_import(item_list.syntax(), &path, &segments, &mut text_edit);
                    edit.set_edit_builder(text_edit);
                },
            );
@@ -566,7 +575,7 @@ pub(crate) fn auto_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
            format!("import {} in the current file", fmt_segments(&segments)),
            |edit| {
                let mut text_edit = TextEditBuilder::default();
-                apply_auto_import(current_file.syntax(), path, &segments, &mut text_edit);
+                apply_auto_import(current_file.syntax(), &path, &segments, &mut text_edit);
                edit.set_edit_builder(text_edit);
            },
        );
diff --git a/crates/ra_assists/src/change_visibility.rs b/crates/ra_assists/src/change_visibility.rs
index 6cabba3e3..ab10d2aa4 100644
--- a/crates/ra_assists/src/change_visibility.rs
+++ b/crates/ra_assists/src/change_visibility.rs
@@ -35,7 +35,7 @@ fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        if parent.children().any(|child| child.kind() == VISIBILITY) {
            return None;
        }
-        (vis_offset(parent), keyword.range())
+        (vis_offset(&parent), keyword.range())
    } else {
        let ident = ctx.token_at_offset().find(|leaf| leaf.kind() == IDENT)?;
        let field = ident.parent().ancestors().find_map(ast::NamedFieldDef::cast)?;
@@ -65,7 +65,7 @@ fn vis_offset(node: &SyntaxNode) -> TextUnit {
        .unwrap_or_else(|| node.range().start())
 }
-fn change_vis(mut ctx: AssistCtx<impl HirDatabase>, vis: &ast::Visibility) -> Option<Assist> {
+fn change_vis(mut ctx: AssistCtx<impl HirDatabase>, vis: ast::Visibility) -> Option<Assist> {
    if vis.syntax().text() == "pub" {
        ctx.add_action(AssistId("change_visibility"), "change to pub(crate)", |edit| {
            edit.target(vis.syntax().range());
diff --git a/crates/ra_assists/src/fill_match_arms.rs b/crates/ra_assists/src/fill_match_arms.rs
index deef166b5..b96806ac6 100644
--- a/crates/ra_assists/src/fill_match_arms.rs
+++ b/crates/ra_assists/src/fill_match_arms.rs
@@ -27,7 +27,7 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
        let mut arm_iter = arm_list.arms();
        let first = arm_iter.next();
-        match first {
+        match &first {
            // If there arm list is empty or there is only one trivial arm, then proceed.
            Some(arm) if is_trivial_arm(arm) => {
                if arm_iter.next() != None {
@@ -44,7 +44,7 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
    let expr = match_expr.expr()?;
    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, expr.syntax(), None);
-    let match_expr_ty = analyzer.type_of(ctx.db, expr)?;
+    let match_expr_ty = analyzer.type_of(ctx.db, &expr)?;
    let enum_def = analyzer.autoderef(ctx.db, match_expr_ty).find_map(|ty| match ty.as_adt() {
        Some((AdtDef::Enum(e), _)) => Some(e),
        _ => None,
diff --git a/crates/ra_assists/src/flip_binexpr.rs b/crates/ra_assists/src/flip_binexpr.rs
index 5e41f9346..2e591ad3b 100644
--- a/crates/ra_assists/src/flip_binexpr.rs
+++ b/crates/ra_assists/src/flip_binexpr.rs
@@ -6,8 +6,8 @@ use crate::{Assist, AssistCtx, AssistId};
 /// Flip binary expression assist.
 pub(crate) fn flip_binexpr(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let expr = ctx.node_at_offset::<BinExpr>()?;
-    let lhs = expr.lhs()?.syntax();
+    let lhs = expr.lhs()?.syntax().clone();
-    let rhs = expr.rhs()?.syntax();
+    let rhs = expr.rhs()?.syntax().clone();
    let op_range = expr.op_token()?.range();
    // The assist should be applied only if the cursor is on the operator
    let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
diff --git a/crates/ra_assists/src/flip_comma.rs b/crates/ra_assists/src/flip_comma.rs
index d8dba779f..13016ae06 100644
--- a/crates/ra_assists/src/flip_comma.rs
+++ b/crates/ra_assists/src/flip_comma.rs
@@ -5,8 +5,8 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn flip_comma(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == T![,])?;
-    let prev = non_trivia_sibling(comma.into(), Direction::Prev)?;
+    let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?;
-    let next = non_trivia_sibling(comma.into(), Direction::Next)?;
+    let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?;
    ctx.add_action(AssistId("flip_comma"), "flip comma", |edit| {
        edit.target(comma.range());
        edit.replace(prev.range(), next.to_string());
diff --git a/crates/ra_assists/src/inline_local_variable.rs b/crates/ra_assists/src/inline_local_variable.rs
index 554de8b46..3c17089de 100644
--- a/crates/ra_assists/src/inline_local_variable.rs
+++ b/crates/ra_assists/src/inline_local_variable.rs
@@ -16,18 +16,18 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
    if bind_pat.is_mutable() {
        return None;
    }
-    let initializer_expr = let_stmt.initializer();
+    let initializer_expr = let_stmt.initializer()?;
    let delete_range = if let Some(whitespace) = let_stmt
        .syntax()
        .next_sibling_or_token()
-        .and_then(|it| ast::Whitespace::cast(it.as_token()?))
+        .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
    {
        TextRange::from_to(let_stmt.syntax().range().start(), whitespace.syntax().range().end())
    } else {
        let_stmt.syntax().range()
    };
    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, bind_pat.syntax(), None);
-    let refs = analyzer.find_all_refs(bind_pat);
+    let refs = analyzer.find_all_refs(&bind_pat);
    let mut wrap_in_parens = vec![true; refs.len()];
@@ -45,7 +45,7 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
            }
        };
-        wrap_in_parens[i] = match (initializer_expr?.kind(), usage_parent.kind()) {
+        wrap_in_parens[i] = match (initializer_expr.kind(), usage_parent.kind()) {
            (ExprKind::CallExpr(_), _)
            | (ExprKind::IndexExpr(_), _)
            | (ExprKind::MethodCallExpr(_), _)
@@ -71,7 +71,7 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
        };
    }
-    let init_str = initializer_expr?.syntax().text().to_string();
+    let init_str = initializer_expr.syntax().text().to_string();
    let init_in_paren = format!("({})", &init_str);
    ctx.add_action(
diff --git a/crates/ra_assists/src/introduce_variable.rs b/crates/ra_assists/src/introduce_variable.rs
index f7f5ccafa..ce28132c9 100644
--- a/crates/ra_assists/src/introduce_variable.rs
+++ b/crates/ra_assists/src/introduce_variable.rs
@@ -20,8 +20,8 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
        return None;
    }
    let expr = node.ancestors().find_map(valid_target_expr)?;
-    let (anchor_stmt, wrap_in_block) = anchor_stmt(expr)?;
+    let (anchor_stmt, wrap_in_block) = anchor_stmt(expr.clone())?;
-    let indent = anchor_stmt.prev_sibling_or_token()?.as_token()?;
+    let indent = anchor_stmt.prev_sibling_or_token()?.as_token()?.clone();
    if indent.kind() != WHITESPACE {
        return None;
    }
@@ -37,9 +37,9 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
        };
        expr.syntax().text().push_to(&mut buf);
-        let full_stmt = ast::ExprStmt::cast(anchor_stmt);
+        let full_stmt = ast::ExprStmt::cast(anchor_stmt.clone());
-        let is_full_stmt = if let Some(expr_stmt) = full_stmt {
+        let is_full_stmt = if let Some(expr_stmt) = &full_stmt {
-            Some(expr.syntax()) == expr_stmt.expr().map(|e| e.syntax())
+            Some(expr.syntax().clone()) == expr_stmt.expr().map(|e| e.syntax().clone())
        } else {
            false
        };
@@ -81,7 +81,7 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
 /// Check whether the node is a valid expression which can be extracted to a variable.
 /// In general that's true for any expression, but in some cases that would produce invalid code.
-fn valid_target_expr(node: &SyntaxNode) -> Option<&ast::Expr> {
+fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
    match node.kind() {
        PATH_EXPR => None,
        BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
@@ -96,14 +96,10 @@ fn valid_target_expr(node: &SyntaxNode) -> Option<&ast::Expr> {
 /// to produce correct code.
 /// It can be a statement, the last in a block expression or a wanna be block
 /// expression like a lambda or match arm.
-fn anchor_stmt(expr: &ast::Expr) -> Option<(&SyntaxNode, bool)> {
+fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
    expr.syntax().ancestors().find_map(|node| {
-        if ast::Stmt::cast(node).is_some() {
-            return Some((node, false));
-        }
        if let Some(expr) = node.parent().and_then(ast::Block::cast).and_then(|it| it.expr()) {
-            if expr.syntax() == node {
+            if expr.syntax() == &node {
                tested_by!(test_introduce_var_last_expr);
                return Some((node, false));
            }
@@ -115,6 +111,10 @@ fn anchor_stmt(expr: &ast::Expr) -> Option<(&SyntaxNode, bool)> {
            }
        }
+        if ast::Stmt::cast(node.clone()).is_some() {
+            return Some((node, false));
+        }
        None
    })
 }
diff --git a/crates/ra_assists/src/move_guard.rs b/crates/ra_assists/src/move_guard.rs
index e1ce86a33..313c9ad18 100644
--- a/crates/ra_assists/src/move_guard.rs
+++ b/crates/ra_assists/src/move_guard.rs
@@ -18,9 +18,9 @@ pub(crate) fn move_guard_to_arm_body(mut ctx: AssistCtx<impl HirDatabase>) -> Op
    ctx.add_action(AssistId("move_guard_to_arm_body"), "move guard to arm body", |edit| {
        edit.target(guard.syntax().range());
-        let offseting_amount = match space_before_guard {
+        let offseting_amount = match &space_before_guard {
            Some(SyntaxElement::Token(tok)) => {
-                if let Some(_) = ast::Whitespace::cast(tok) {
+                if let Some(_) = ast::Whitespace::cast(tok.clone()) {
                    let ele = space_before_guard.unwrap().range();
                    edit.delete(ele);
                    ele.len()
@@ -39,11 +39,11 @@ pub(crate) fn move_guard_to_arm_body(mut ctx: AssistCtx<impl HirDatabase>) -> Op
 }
 pub(crate) fn move_arm_cond_to_match_guard(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let match_arm: &MatchArm = ctx.node_at_offset::<MatchArm>()?;
+    let match_arm: MatchArm = ctx.node_at_offset::<MatchArm>()?;
    let last_match_pat = match_arm.pats().last()?;
    let arm_body = match_arm.expr()?;
-    let if_expr: &IfExpr = IfExpr::cast(arm_body.syntax())?;
+    let if_expr: IfExpr = IfExpr::cast(arm_body.syntax().clone())?;
    let cond = if_expr.condition()?;
    let then_block = if_expr.then_branch()?;
@@ -65,7 +65,7 @@ pub(crate) fn move_arm_cond_to_match_guard(mut ctx: AssistCtx<impl HirDatabase>)
            edit.target(if_expr.syntax().range());
            let then_only_expr = then_block.statements().next().is_none();
-            match then_block.expr() {
+            match &then_block.expr() {
                Some(then_expr) if then_only_expr => {
                    edit.replace(if_expr.syntax().range(), then_expr.syntax().text())
                }
diff --git a/crates/ra_assists/src/remove_dbg.rs b/crates/ra_assists/src/remove_dbg.rs
index 5680f76ca..c330bc827 100644
--- a/crates/ra_assists/src/remove_dbg.rs
+++ b/crates/ra_assists/src/remove_dbg.rs
@@ -8,7 +8,7 @@ use ra_syntax::{
 pub(crate) fn remove_dbg(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let macro_call = ctx.node_at_offset::<ast::MacroCall>()?;
-    if !is_valid_macrocall(macro_call, "dbg")? {
+    if !is_valid_macrocall(&macro_call, "dbg")? {
        return None;
    }
@@ -35,7 +35,7 @@ pub(crate) fn remove_dbg(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
    };
    let macro_content = {
-        let macro_args = macro_call.token_tree()?.syntax();
+        let macro_args = macro_call.token_tree()?.syntax().clone();
        let range = macro_args.range();
        let start = range.start() + TextUnit::of_char('(');
        let end = range.end() - TextUnit::of_char(')');
@@ -65,7 +65,7 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
        return None;
    }
-    let node = macro_call.token_tree()?.syntax();
+    let node = macro_call.token_tree()?.syntax().clone();
    let first_child = node.first_child_or_token()?;
    let last_child = node.last_child_or_token()?;
diff --git a/crates/ra_assists/src/replace_if_let_with_match.rs b/crates/ra_assists/src/replace_if_let_with_match.rs
index c2c7cf70b..5de6aa266 100644
--- a/crates/ra_assists/src/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/replace_if_let_with_match.rs
@@ -5,7 +5,7 @@ use ra_syntax::{ast, AstNode};
 use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn replace_if_let_with_match(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let if_expr: &ast::IfExpr = ctx.node_at_offset()?;
+    let if_expr: ast::IfExpr = ctx.node_at_offset()?;
    let cond = if_expr.condition()?;
    let pat = cond.pat()?;
    let expr = cond.expr()?;
@@ -25,16 +25,11 @@ pub(crate) fn replace_if_let_with_match(mut ctx: AssistCtx<impl HirDatabase>) ->
    ctx.build()
 }
-fn build_match_expr(
+fn build_match_expr(expr: ast::Expr, pat1: ast::Pat, arm1: ast::Block, arm2: ast::Block) -> String {
-    expr: &ast::Expr,
-    pat1: &ast::Pat,
-    arm1: &ast::Block,
-    arm2: &ast::Block,
-) -> String {
    let mut buf = String::new();
    buf.push_str(&format!("match {} {{\n", expr.syntax().text()));
-    buf.push_str(&format!("    {} => {}\n", pat1.syntax().text(), format_arm(arm1)));
+    buf.push_str(&format!("    {} => {}\n", pat1.syntax().text(), format_arm(&arm1)));
-    buf.push_str(&format!("    _ => {}\n", format_arm(arm2)));
+    buf.push_str(&format!("    _ => {}\n", format_arm(&arm2)));
    buf.push_str("}");
    buf
 }
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index b063193cf..375e2f508 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -7,7 +7,7 @@ use clap::{App, Arg, SubCommand};
 use flexi_logger::Logger;
 use ra_ide_api::{file_structure, Analysis};
 use ra_prof::profile;
-use ra_syntax::{AstNode, SourceFile, TreeArc};
+use ra_syntax::{AstNode, SourceFile};
 type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
@@ -100,9 +100,9 @@ fn main() -> Result<()> {
    Ok(())
 }
-fn file() -> Result<TreeArc<SourceFile>> {
+fn file() -> Result<SourceFile> {
    let text = read_stdin()?;
-    Ok(SourceFile::parse(&text).tree().to_owned())
+    Ok(SourceFile::parse(&text).tree())
 }
 fn read_stdin() -> Result<String> {
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index 1c2c04ad2..d6e895729 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -3,7 +3,7 @@
 use itertools::Itertools;
 use ra_syntax::{
    ast::{self, AstNode, AstToken},
-    SyntaxKind,
+    SmolStr, SyntaxKind,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, T,
 };
@@ -15,12 +15,12 @@ pub fn reindent(text: &str, indent: &str) -> String {
 }
 /// If the node is on the beginning of the line, calculate indent.
-pub fn leading_indent(node: &SyntaxNode) -> Option<&str> {
+pub fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
    for token in prev_tokens(node.first_token()?) {
-        if let Some(ws) = ast::Whitespace::cast(token) {
+        if let Some(ws) = ast::Whitespace::cast(token.clone()) {
            let ws_text = ws.text();
            if let Some(pos) = ws_text.rfind('\n') {
-                return Some(&ws_text[pos + 1..]);
+                return Some(ws_text[pos + 1..].into());
            }
        }
        if token.text().contains('\n') {
@@ -31,17 +31,17 @@ pub fn leading_indent(node: &SyntaxNode) -> Option<&str> {
 }
 fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
-    successors(token.prev_token(), |&token| token.prev_token())
+    successors(token.prev_token(), |token| token.prev_token())
 }
-pub fn extract_trivial_expression(block: &ast::Block) -> Option<&ast::Expr> {
+pub fn extract_trivial_expression(block: &ast::Block) -> Option<ast::Expr> {
    let expr = block.expr()?;
    if expr.syntax().text().contains('\n') {
        return None;
    }
    let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
        WHITESPACE | T!['{'] | T!['}'] => false,
-        _ => it != &expr.syntax(),
+        _ => it != expr.syntax(),
    });
    if non_trivial_children.count() > 0 {
        return None;
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 8afdac801..c65446df4 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -4,10 +4,7 @@
 use std::sync::Arc;
 use ra_arena::{impl_arena_id, Arena, RawId};
-use ra_syntax::{
+use ra_syntax::ast::{self, NameOwner, StructKind, TypeAscriptionOwner};
-    ast::{self, NameOwner, StructKind, TypeAscriptionOwner},
-    TreeArc,
-};
 use crate::{
    type_ref::TypeRef, AsName, AstDatabase, Crate, DefDatabase, Enum, EnumVariant, FieldSource,
@@ -59,11 +56,11 @@ impl StructData {
        struct_: Struct,
    ) -> Arc<StructData> {
        let src = struct_.source(db);
-        Arc::new(StructData::new(&*src.ast))
+        Arc::new(StructData::new(&src.ast))
    }
 }
-fn variants(enum_def: &ast::EnumDef) -> impl Iterator<Item = &ast::EnumVariant> {
+fn variants(enum_def: &ast::EnumDef) -> impl Iterator<Item = ast::EnumVariant> {
    enum_def.variant_list().into_iter().flat_map(|it| it.variants())
 }
@@ -71,9 +68,9 @@ impl EnumVariant {
    pub(crate) fn source_impl(
        self,
        db: &(impl DefDatabase + AstDatabase),
-    ) -> Source<TreeArc<ast::EnumVariant>> {
+    ) -> Source<ast::EnumVariant> {
        let src = self.parent.source(db);
-        let ast = variants(&*src.ast)
+        let ast = variants(&src.ast)
            .zip(db.enum_data(self.parent).variants.iter())
            .find(|(_syntax, (id, _))| *id == self.id)
            .unwrap()
@@ -96,7 +93,7 @@ impl EnumData {
    pub(crate) fn enum_data_query(db: &(impl DefDatabase + AstDatabase), e: Enum) -> Arc<EnumData> {
        let src = e.source(db);
        let name = src.ast.name().map(|n| n.as_name());
-        let variants = variants(&*src.ast)
+        let variants = variants(&src.ast)
            .map(|var| EnumVariantData {
                name: var.name().map(|it| it.as_name()),
                variant_data: Arc::new(VariantData::new(var.kind())),
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 4fb5844f4..779764590 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -4,10 +4,7 @@ pub(crate) mod docs;
 use std::sync::Arc;
 use ra_db::{CrateId, Edition, FileId, SourceRootId};
-use ra_syntax::{
+use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
-    ast::{self, NameOwner, TypeAscriptionOwner},
-    TreeArc,
-};
 use crate::{
    adt::{EnumVariantId, StructFieldId, VariantDef},
@@ -155,8 +152,8 @@ impl_froms!(
 );
 pub enum ModuleSource {
-    SourceFile(TreeArc<ast::SourceFile>),
+    SourceFile(ast::SourceFile),
-    Module(TreeArc<ast::Module>),
+    Module(ast::Module),
 }
 impl ModuleSource {
@@ -199,7 +196,7 @@ impl Module {
        self,
        db: &impl HirDatabase,
        import: ImportId,
-    ) -> Either<TreeArc<ast::UseTree>, TreeArc<ast::ExternCrateItem>> {
+    ) -> Either<ast::UseTree, ast::ExternCrateItem> {
        let src = self.definition_source(db);
        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
        source_map.get(&src.ast, import)
@@ -321,8 +318,8 @@ pub struct StructField {
 #[derive(Debug)]
 pub enum FieldSource {
-    Named(TreeArc<ast::NamedFieldDef>),
+    Named(ast::NamedFieldDef),
-    Pos(TreeArc<ast::PosFieldDef>),
+    Pos(ast::PosFieldDef),
 }
 impl StructField {
@@ -736,7 +733,7 @@ impl ConstData {
        konst: Const,
    ) -> Arc<ConstData> {
        let node = konst.source(db).ast;
-        const_data_for(&*node)
+        const_data_for(&node)
    }
    pub(crate) fn static_data_query(
@@ -744,7 +741,7 @@ impl ConstData {
        konst: Static,
    ) -> Arc<ConstData> {
        let node = konst.source(db).ast;
-        const_data_for(&*node)
+        const_data_for(&node)
    }
 }
diff --git a/crates/ra_hir/src/code_model/docs.rs b/crates/ra_hir/src/code_model/docs.rs
index 007ef315d..a2b4d8e97 100644
--- a/crates/ra_hir/src/code_model/docs.rs
+++ b/crates/ra_hir/src/code_model/docs.rs
@@ -71,21 +71,21 @@ pub(crate) fn documentation_query(
    def: DocDef,
 ) -> Option<Documentation> {
    match def {
-        DocDef::Module(it) => docs_from_ast(&*it.declaration_source(db)?.ast),
+        DocDef::Module(it) => docs_from_ast(&it.declaration_source(db)?.ast),
        DocDef::StructField(it) => match it.source(db).ast {
-            FieldSource::Named(named) => docs_from_ast(&*named),
+            FieldSource::Named(named) => docs_from_ast(&named),
            FieldSource::Pos(..) => None,
        },
-        DocDef::Struct(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Struct(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Enum(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Enum(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::EnumVariant(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::EnumVariant(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Static(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Static(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Const(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Const(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Function(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Function(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Union(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Union(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::Trait(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Trait(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::TypeAlias(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::TypeAlias(it) => docs_from_ast(&it.source(db).ast),
-        DocDef::MacroDef(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::MacroDef(it) => docs_from_ast(&it.source(db).ast),
    }
 }
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index 72451e0e7..32bd9c661 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,4 +1,4 @@
-use ra_syntax::{ast, TreeArc};
+use ra_syntax::ast;
 use crate::{
    ids::AstItemDef, AstDatabase, Const, DefDatabase, Enum, EnumVariant, FieldSource, Function,
@@ -34,7 +34,7 @@ impl Module {
    pub fn declaration_source(
        self,
        db: &(impl DefDatabase + AstDatabase),
-    ) -> Option<Source<TreeArc<ast::Module>>> {
+    ) -> Option<Source<ast::Module>> {
        let def_map = db.crate_def_map(self.krate);
        let decl = def_map[self.module_id].declaration?;
        let ast = decl.to_node(db);
@@ -49,62 +49,62 @@ impl HasSource for StructField {
    }
 }
 impl HasSource for Struct {
-    type Ast = TreeArc<ast::StructDef>;
+    type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StructDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
        self.id.source(db)
    }
 }
 impl HasSource for Union {
-    type Ast = TreeArc<ast::StructDef>;
+    type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StructDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
        self.id.source(db)
    }
 }
 impl HasSource for Enum {
-    type Ast = TreeArc<ast::EnumDef>;
+    type Ast = ast::EnumDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::EnumDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumDef> {
        self.id.source(db)
    }
 }
 impl HasSource for EnumVariant {
-    type Ast = TreeArc<ast::EnumVariant>;
+    type Ast = ast::EnumVariant;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::EnumVariant>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumVariant> {
        self.source_impl(db)
    }
 }
 impl HasSource for Function {
-    type Ast = TreeArc<ast::FnDef>;
+    type Ast = ast::FnDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::FnDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::FnDef> {
        self.id.source(db)
    }
 }
 impl HasSource for Const {
-    type Ast = TreeArc<ast::ConstDef>;
+    type Ast = ast::ConstDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::ConstDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ConstDef> {
        self.id.source(db)
    }
 }
 impl HasSource for Static {
-    type Ast = TreeArc<ast::StaticDef>;
+    type Ast = ast::StaticDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StaticDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StaticDef> {
        self.id.source(db)
    }
 }
 impl HasSource for Trait {
-    type Ast = TreeArc<ast::TraitDef>;
+    type Ast = ast::TraitDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::TraitDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TraitDef> {
        self.id.source(db)
    }
 }
 impl HasSource for TypeAlias {
-    type Ast = TreeArc<ast::TypeAliasDef>;
+    type Ast = ast::TypeAliasDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::TypeAliasDef>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TypeAliasDef> {
        self.id.source(db)
    }
 }
 impl HasSource for MacroDef {
-    type Ast = TreeArc<ast::MacroCall>;
+    type Ast = ast::MacroCall;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::MacroCall>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::MacroCall> {
        Source { file_id: self.id.0.file_id(), ast: self.id.0.to_node(db) }
    }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index da9f3e32d..358365176 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 use parking_lot::Mutex;
 use ra_db::{salsa, SourceDatabase};
-use ra_syntax::{ast, Parse, SmolStr, SyntaxNode, TreeArc};
+use ra_syntax::{ast, Parse, SmolStr, SyntaxNode};
 use crate::{
    adt::{EnumData, StructData},
@@ -62,11 +62,11 @@ pub trait AstDatabase: InternDatabase {
    #[salsa::transparent]
    #[salsa::invoke(crate::source_id::AstIdMap::file_item_query)]
-    fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> TreeArc<SyntaxNode>;
+    fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode;
    #[salsa::transparent]
    #[salsa::invoke(crate::ids::HirFileId::parse_or_expand_query)]
-    fn parse_or_expand(&self, file_id: HirFileId) -> Option<TreeArc<SyntaxNode>>;
+    fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
    #[salsa::invoke(crate::ids::HirFileId::parse_macro_query)]
    fn parse_macro(&self, macro_file: ids::MacroFile) -> Option<Parse<SyntaxNode>>;
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index c97f0656d..0290483b3 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -1,6 +1,6 @@
 use std::{any::Any, fmt};
-use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange, TreeArc};
+use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange};
 use relative_path::RelativePathBuf;
 use crate::{HirDatabase, HirFileId, Name};
@@ -33,9 +33,9 @@ pub trait AstDiagnostic {
 }
 impl dyn Diagnostic {
-    pub fn syntax_node(&self, db: &impl HirDatabase) -> TreeArc<SyntaxNode> {
+    pub fn syntax_node(&self, db: &impl HirDatabase) -> SyntaxNode {
        let node = db.parse_or_expand(self.file()).unwrap();
-        self.syntax_node_ptr().to_node(&*node).to_owned()
+        self.syntax_node_ptr().to_node(&node)
    }
    pub fn downcast_ref<D: Diagnostic>(&self) -> Option<&D> {
@@ -143,11 +143,11 @@ impl Diagnostic for MissingFields {
 }
 impl AstDiagnostic for MissingFields {
-    type AST = TreeArc<ast::NamedFieldList>;
+    type AST = ast::NamedFieldList;
    fn ast(&self, db: &impl HirDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.file()).unwrap();
-        let node = self.syntax_node_ptr().to_node(&*root);
+        let node = self.syntax_node_ptr().to_node(&root);
-        ast::NamedFieldList::cast(&node).unwrap().to_owned()
+        ast::NamedFieldList::cast(node).unwrap()
    }
 }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 3a97d97ce..70af3f119 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -550,7 +550,7 @@ where
        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 = SyntaxNodePtr::new(expr.syntax());
        match expr.kind() {
            ast::ExprKind::IfExpr(e) => {
@@ -565,7 +565,8 @@ where
                        .map(|b| match b {
                            ast::ElseBranch::Block(it) => self.collect_block(it),
                            ast::ElseBranch::IfExpr(elif) => {
-                                let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
+                                let expr: ast::Expr =
+                                    ast::Expr::cast(elif.syntax().clone()).unwrap();
                                self.collect_expr(expr)
                            }
                        })
@@ -582,7 +583,7 @@ where
                    let else_branch = e.else_branch().map(|b| match b {
                        ast::ElseBranch::Block(it) => self.collect_block(it),
                        ast::ElseBranch::IfExpr(elif) => {
-                            let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
+                            let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
                            self.collect_expr(expr)
                        }
                    });
@@ -689,7 +690,7 @@ where
                let struct_lit = if let Some(nfl) = e.named_field_list() {
                    let fields = nfl
                        .fields()
-                        .inspect(|field| field_ptrs.push(AstPtr::new(*field)))
+                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                        .map(|field| StructLitField {
                            name: field
                                .name_ref()
@@ -699,7 +700,7 @@ where
                                self.collect_expr(e)
                            } else if let Some(nr) = field.name_ref() {
                                // field shorthand
-                                let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(nr)));
+                                let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr)));
                                self.source_map
                                    .expr_map
                                    .insert(SyntaxNodePtr::new(nr.syntax()), id);
@@ -837,7 +838,7 @@ where
                let ast_id = self
                    .db
                    .ast_id_map(self.current_file_id)
-                    .ast_id(e)
+                    .ast_id(&e)
                    .with_file_id(self.current_file_id);
                if let Some(path) = e.path().and_then(Path::from_ast) {
@@ -845,11 +846,11 @@ where
                        let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
                        let file_id = call_id.as_file(MacroFileKind::Expr);
                        if let Some(node) = self.db.parse_or_expand(file_id) {
-                            if let Some(expr) = ast::Expr::cast(&*node) {
+                            if let Some(expr) = ast::Expr::cast(node) {
                                log::debug!("macro expansion {}", expr.syntax().debug_dump());
                                let old_file_id =
                                    std::mem::replace(&mut self.current_file_id, file_id);
-                                let id = self.collect_expr(&expr);
+                                let id = self.collect_expr(expr);
                                self.current_file_id = old_file_id;
                                return id;
                            }
@@ -863,7 +864,7 @@ where
        }
    }
-    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 {
@@ -871,7 +872,7 @@ where
        }
    }
-    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.kind() {
@@ -890,7 +891,7 @@ where
        self.alloc_expr(Expr::Block { statements, tail }, SyntaxNodePtr::new(block.syntax()))
    }
-    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 {
@@ -898,7 +899,7 @@ where
        }
    }
-    fn collect_pat(&mut self, pat: &ast::Pat) -> PatId {
+    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
        let pattern = match pat.kind() {
            ast::PatKind::BindPat(bp) => {
                let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
@@ -932,7 +933,8 @@ where
                let mut fields: Vec<_> = field_pat_list
                    .bind_pats()
                    .filter_map(|bind_pat| {
-                        let ast_pat = ast::Pat::cast(bind_pat.syntax()).expect("bind pat is a pat");
+                        let ast_pat =
+                            ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat");
                        let pat = self.collect_pat(ast_pat);
                        let name = bind_pat.name()?.as_name();
                        Some(FieldPat { name, pat })
@@ -953,11 +955,11 @@ where
            ast::PatKind::LiteralPat(_) => Pat::Missing,
            ast::PatKind::SlicePat(_) | ast::PatKind::RangePat(_) => Pat::Missing,
        };
-        let ptr = AstPtr::new(pat);
+        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::A(ptr))
    }
-    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 {
@@ -965,20 +967,20 @@ where
        }
    }
-    fn collect_const_body(&mut self, node: &ast::ConstDef) {
+    fn collect_const_body(&mut self, node: ast::ConstDef) {
        let body = self.collect_expr_opt(node.body());
        self.body_expr = Some(body);
    }
-    fn collect_static_body(&mut self, node: &ast::StaticDef) {
+    fn collect_static_body(&mut self, node: ast::StaticDef) {
        let body = self.collect_expr_opt(node.body());
        self.body_expr = Some(body);
    }
-    fn collect_fn_body(&mut self, node: &ast::FnDef) {
+    fn collect_fn_body(&mut self, node: ast::FnDef) {
        if let Some(param_list) = node.param_list() {
            if let Some(self_param) = param_list.self_param() {
-                let ptr = AstPtr::new(self_param);
+                let ptr = AstPtr::new(&self_param);
                let param_pat = self.alloc_pat(
                    Pat::Bind {
                        name: SELF_PARAM,
@@ -1027,17 +1029,17 @@ pub(crate) fn body_with_source_map_query(
        DefWithBody::Const(ref c) => {
            let src = c.source(db);
            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
-            collector.collect_const_body(&src.ast)
+            collector.collect_const_body(src.ast)
        }
        DefWithBody::Function(ref f) => {
            let src = f.source(db);
            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
-            collector.collect_fn_body(&src.ast)
+            collector.collect_fn_body(src.ast)
        }
        DefWithBody::Static(ref s) => {
            let src = s.source(db);
            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
-            collector.collect_static_body(&src.ast)
+            collector.collect_static_body(src.ast)
        }
    }
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index 28fd52684..6589b782c 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -190,7 +190,7 @@ mod tests {
        let (db, _source_root, file_id) = MockDatabase::with_single_file(&code);
        let file = db.parse(file_id).ok().unwrap();
-        let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
+        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
        let analyzer = SourceAnalyzer::new(&db, file_id, marker.syntax(), None);
        let scopes = analyzer.scopes();
@@ -290,10 +290,10 @@ mod tests {
        let file = db.parse(file_id).ok().unwrap();
        let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
            .expect("failed to find a name at the target offset");
-        let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
+        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
        let analyzer = SourceAnalyzer::new(&db, file_id, name_ref.syntax(), None);
-        let local_name_entry = analyzer.resolve_local_name(name_ref).unwrap();
+        let local_name_entry = analyzer.resolve_local_name(&name_ref).unwrap();
        let local_name =
            local_name_entry.ptr().either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
        assert_eq!(local_name.range(), expected_name.syntax().range());
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index c2a10a0b5..82a06ca25 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -79,7 +79,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            .and_then(StructLit::cast)
            .and_then(|lit| lit.named_field_list())
        {
-            let field_list_ptr = AstPtr::new(field_list_node);
+            let field_list_ptr = AstPtr::new(&field_list_node);
            self.sink.push(MissingFields {
                file: file_id,
                field_list: field_list_ptr,
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index 07a59193f..bcbb4988d 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -76,17 +76,17 @@ impl GenericParams {
        generics.parent_params = parent.map(|p| db.generic_params(p));
        let start = generics.parent_params.as_ref().map(|p| p.params.len()).unwrap_or(0) as u32;
        match def {
-            GenericDef::Function(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Function(it) => generics.fill(&it.source(db).ast, start),
-            GenericDef::Struct(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Struct(it) => generics.fill(&it.source(db).ast, start),
-            GenericDef::Union(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Union(it) => generics.fill(&it.source(db).ast, start),
-            GenericDef::Enum(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Enum(it) => generics.fill(&it.source(db).ast, start),
            GenericDef::Trait(it) => {
                // traits get the Self type as an implicit first type parameter
                generics.params.push(GenericParam { idx: start, name: SELF_TYPE, default: None });
-                generics.fill(&*it.source(db).ast, start + 1);
+                generics.fill(&it.source(db).ast, start + 1);
            }
-            GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::TypeAlias(it) => generics.fill(&it.source(db).ast, start),
-            GenericDef::ImplBlock(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::ImplBlock(it) => generics.fill(&it.source(db).ast, start),
            GenericDef::EnumVariant(_) => {}
        }
@@ -102,9 +102,9 @@ impl GenericParams {
        }
    }
-    fn fill_params(&mut self, params: &ast::TypeParamList, start: u32) {
+    fn fill_params(&mut self, params: ast::TypeParamList, start: u32) {
        for (idx, type_param) in params.type_params().enumerate() {
-            let name = type_param.name().map(AsName::as_name).unwrap_or_else(Name::missing);
+            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
            let default = type_param.default_type().and_then(|t| t.path()).and_then(Path::from_ast);
            let param = GenericParam { idx: idx as u32 + start, name: name.clone(), default };
@@ -121,7 +121,7 @@ impl GenericParams {
        }
    }
-    fn fill_where_predicates(&mut self, where_clause: &ast::WhereClause) {
+    fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) {
        for pred in where_clause.predicates() {
            let type_ref = match pred.type_ref() {
                Some(type_ref) => type_ref,
@@ -134,7 +134,7 @@ impl GenericParams {
        }
    }
-    fn add_where_predicate_from_bound(&mut self, bound: &ast::TypeBound, type_ref: TypeRef) {
+    fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
        let path = bound
            .type_ref()
            .and_then(|tr| match tr.kind() {
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 83f5c3f39..05a18eb56 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -6,7 +6,7 @@ use std::{
 use mbe::MacroRules;
 use ra_db::{salsa, FileId};
 use ra_prof::profile;
-use ra_syntax::{ast, AstNode, Parse, SyntaxNode, TreeArc};
+use ra_syntax::{ast, AstNode, Parse, SyntaxNode};
 use crate::{AstDatabase, AstId, DefDatabase, FileAstId, InternDatabase, Module, Source};
@@ -58,11 +58,11 @@ impl HirFileId {
    pub(crate) fn parse_or_expand_query(
        db: &impl AstDatabase,
        file_id: HirFileId,
-    ) -> Option<TreeArc<SyntaxNode>> {
+    ) -> Option<SyntaxNode> {
        match file_id.0 {
-            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().to_owned()),
+            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
            HirFileIdRepr::Macro(macro_file) => {
-                db.parse_macro(macro_file).map(|it| it.tree().to_owned())
+                db.parse_macro(macro_file).map(|it| it.syntax_node())
            }
        }
    }
@@ -123,7 +123,7 @@ pub struct MacroDefId(pub(crate) AstId<ast::MacroCall>);
 pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
    let macro_call = id.0.to_node(db);
    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(arg).or_else(|| {
+    let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| {
        log::warn!("fail on macro_def to token tree: {:#?}", arg);
        None
    })?;
@@ -138,7 +138,7 @@ pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option<
    let loc = id.loc(db);
    let macro_call = loc.ast_id.to_node(db);
    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(arg)?;
+    let (tt, _) = mbe::ast_to_token_tree(&arg)?;
    Some(Arc::new(tt))
 }
@@ -262,7 +262,7 @@ pub(crate) trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
        let loc = ItemLoc { module: ctx.module, ast_id: ast_id.with_file_id(ctx.file_id) };
        Self::intern(ctx.db, loc)
    }
-    fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source<TreeArc<N>> {
+    fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source<N> {
        let loc = self.lookup_intern(db);
        let ast = loc.ast_id.to_node(db);
        Source { file_id: loc.ast_id.file_id(), ast }
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index ce134b27a..8e62cf66d 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -4,7 +4,7 @@ use std::sync::Arc;
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{
    ast::{self, AstNode},
-    AstPtr, SourceFile, TreeArc,
+    AstPtr, SourceFile,
 };
 use crate::{
@@ -28,9 +28,9 @@ impl ImplSourceMap {
        self.map.insert(impl_id, AstPtr::new(impl_block))
    }
-    pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> TreeArc<ast::ImplBlock> {
+    pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> ast::ImplBlock {
        let file = match source {
-            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::SourceFile(file) => file.clone(),
            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
        };
@@ -45,8 +45,8 @@ pub struct ImplBlock {
 }
 impl HasSource for ImplBlock {
-    type Ast = TreeArc<ast::ImplBlock>;
+    type Ast = ast::ImplBlock;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::ImplBlock>> {
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
        let source_map = db.impls_in_module_with_source_map(self.module).1;
        let src = self.module.definition_source(db);
        Source { file_id: src.file_id, ast: source_map.get(&src.ast, self.impl_id) }
@@ -132,9 +132,9 @@ impl ImplData {
            item_list
                .impl_items()
                .map(|item_node| match item_node.kind() {
-                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
                })
                .collect()
        } else {
@@ -202,20 +202,20 @@ impl ModuleImplBlocks {
        let src = m.module.definition_source(db);
        let node = match &src.ast {
-            ModuleSource::SourceFile(node) => node.syntax(),
+            ModuleSource::SourceFile(node) => node.syntax().clone(),
            ModuleSource::Module(node) => {
-                node.item_list().expect("inline module should have item list").syntax()
+                node.item_list().expect("inline module should have item list").syntax().clone()
            }
        };
        for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) {
-            let impl_block = ImplData::from_ast(db, src.file_id, m.module, impl_block_ast);
+            let impl_block = ImplData::from_ast(db, src.file_id, m.module, &impl_block_ast);
            let id = m.impls.alloc(impl_block);
            for &impl_item in &m.impls[id].items {
                m.impls_by_def.insert(impl_item, id);
            }
-            source_map.insert(id, impl_block_ast);
+            source_map.insert(id, &impl_block_ast);
        }
        m
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index 0443d4d9a..fd6609fb8 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -1,7 +1,7 @@
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
-use ra_syntax::{ast::AttrsOwner, SmolStr, TreeArc};
+use ra_syntax::{ast::AttrsOwner, SmolStr};
 use crate::{
    AstDatabase, Crate, DefDatabase, Enum, Function, HasSource, HirDatabase, ImplBlock, Module,
@@ -95,7 +95,7 @@ impl LangItems {
        // Look for impl targets
        for impl_block in module.impl_blocks(db) {
            let src = impl_block.source(db);
-            if let Some(lang_item_name) = lang_item_name(&*src.ast) {
+            if let Some(lang_item_name) = lang_item_name(&src.ast) {
                self.items
                    .entry(lang_item_name)
                    .or_insert_with(|| LangItemTarget::ImplBlock(impl_block));
@@ -137,11 +137,11 @@ impl LangItems {
        item: T,
        constructor: fn(T) -> LangItemTarget,
    ) where
-        T: Copy + HasSource<Ast = TreeArc<N>>,
+        T: Copy + HasSource<Ast = N>,
        N: AttrsOwner,
    {
        let node = item.source(db).ast;
-        if let Some(lang_item_name) = lang_item_name(&*node) {
+        if let Some(lang_item_name) = lang_item_name(&node) {
            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
        }
    }
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 40c9d6002..c589f8aba 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -75,7 +75,7 @@ impl AsName for ast::Name {
    }
 }
-impl<'a> AsName for ast::FieldKind<'a> {
+impl AsName for ast::FieldKind {
    fn as_name(&self) -> Name {
        match self {
            ast::FieldKind::Name(nr) => nr.as_name(),
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 46b2bef5b..8517f3c43 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -3,7 +3,7 @@ use std::{ops::Index, sync::Arc};
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{
    ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SmolStr, SourceFile, TreeArc,
+    AstNode, AstPtr, SmolStr, SourceFile,
 };
 use test_utils::tested_by;
@@ -32,7 +32,7 @@ pub struct ImportSourceMap {
 }
 type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-type ImportSource = Either<TreeArc<ast::UseTree>, TreeArc<ast::ExternCrateItem>>;
+type ImportSource = Either<ast::UseTree, ast::ExternCrateItem>;
 impl ImportSourcePtr {
    fn to_node(self, file: &SourceFile) -> ImportSource {
@@ -50,11 +50,11 @@ impl ImportSourceMap {
    pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource {
        let file = match source {
-            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::SourceFile(file) => file.clone(),
            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
        };
-        self.map[import].to_node(file)
+        self.map[import].to_node(&file)
    }
 }
@@ -76,8 +76,8 @@ impl RawItems {
            source_map: ImportSourceMap::default(),
        };
        if let Some(node) = db.parse_or_expand(file_id) {
-            if let Some(source_file) = ast::SourceFile::cast(&node) {
+            if let Some(source_file) = ast::SourceFile::cast(node) {
-                collector.process_module(None, &*source_file);
+                collector.process_module(None, source_file);
            }
        }
        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
@@ -188,7 +188,7 @@ struct RawItemsCollector {
 }
 impl RawItemsCollector {
-    fn process_module(&mut self, current_module: Option<Module>, body: &impl ast::ModuleItemOwner) {
+    fn process_module(&mut self, current_module: Option<Module>, body: impl ast::ModuleItemOwner) {
        for item_or_macro in body.items_with_macros() {
            match item_or_macro {
                ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m),
@@ -197,7 +197,7 @@ impl RawItemsCollector {
        }
    }
-    fn add_item(&mut self, current_module: Option<Module>, item: &ast::ModuleItem) {
+    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
        let (kind, name) = match item.kind() {
            ast::ModuleItemKind::Module(module) => {
                self.add_module(current_module, module);
@@ -216,7 +216,7 @@ impl RawItemsCollector {
                return;
            }
            ast::ModuleItemKind::StructDef(it) => {
-                let id = self.source_ast_id_map.ast_id(it);
+                let id = self.source_ast_id_map.ast_id(&it);
                let name = it.name();
                if it.is_union() {
                    (DefKind::Union(id), name)
@@ -225,22 +225,22 @@ impl RawItemsCollector {
                }
            }
            ast::ModuleItemKind::EnumDef(it) => {
-                (DefKind::Enum(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name())
            }
            ast::ModuleItemKind::FnDef(it) => {
-                (DefKind::Function(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name())
            }
            ast::ModuleItemKind::TraitDef(it) => {
-                (DefKind::Trait(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::Trait(self.source_ast_id_map.ast_id(&it)), it.name())
            }
            ast::ModuleItemKind::TypeAliasDef(it) => {
-                (DefKind::TypeAlias(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::TypeAlias(self.source_ast_id_map.ast_id(&it)), it.name())
            }
            ast::ModuleItemKind::ConstDef(it) => {
-                (DefKind::Const(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::Const(self.source_ast_id_map.ast_id(&it)), it.name())
            }
            ast::ModuleItemKind::StaticDef(it) => {
-                (DefKind::Static(self.source_ast_id_map.ast_id(it)), it.name())
+                (DefKind::Static(self.source_ast_id_map.ast_id(&it)), it.name())
            }
        };
        if let Some(name) = name {
@@ -250,14 +250,14 @@ impl RawItemsCollector {
        }
    }
-    fn add_module(&mut self, current_module: Option<Module>, module: &ast::Module) {
+    fn add_module(&mut self, current_module: Option<Module>, module: ast::Module) {
        let name = match module.name() {
            Some(it) => it.as_name(),
            None => return,
        };
-        let attr_path = extract_mod_path_attribute(module);
+        let attr_path = extract_mod_path_attribute(&module);
-        let ast_id = self.source_ast_id_map.ast_id(module);
+        let ast_id = self.source_ast_id_map.ast_id(&module);
        if module.has_semi() {
            let item =
                self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id, attr_path });
@@ -278,10 +278,10 @@ impl RawItemsCollector {
        tested_by!(name_res_works_for_broken_modules);
    }
-    fn add_use_item(&mut self, current_module: Option<Module>, use_item: &ast::UseItem) {
+    fn add_use_item(&mut self, current_module: Option<Module>, use_item: ast::UseItem) {
        let is_prelude = use_item.has_atom_attr("prelude_import");
-        Path::expand_use_item(use_item, |path, use_tree, is_glob, alias| {
+        Path::expand_use_item(&use_item, |path, use_tree, is_glob, alias| {
            let import_data =
                ImportData { path, alias, is_glob, is_prelude, is_extern_crate: false };
            self.push_import(current_module, import_data, Either::A(AstPtr::new(use_tree)));
@@ -291,11 +291,11 @@ impl RawItemsCollector {
    fn add_extern_crate_item(
        &mut self,
        current_module: Option<Module>,
-        extern_crate: &ast::ExternCrateItem,
+        extern_crate: ast::ExternCrateItem,
    ) {
        if let Some(name_ref) = extern_crate.name_ref() {
-            let path = Path::from_name_ref(name_ref);
+            let path = Path::from_name_ref(&name_ref);
-            let alias = extern_crate.alias().and_then(|a| a.name()).map(AsName::as_name);
+            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
            let import_data = ImportData {
                path,
                alias,
@@ -303,18 +303,18 @@ impl RawItemsCollector {
                is_prelude: false,
                is_extern_crate: true,
            };
-            self.push_import(current_module, import_data, Either::B(AstPtr::new(extern_crate)));
+            self.push_import(current_module, import_data, Either::B(AstPtr::new(&extern_crate)));
        }
    }
-    fn add_macro(&mut self, current_module: Option<Module>, m: &ast::MacroCall) {
+    fn add_macro(&mut self, current_module: Option<Module>, m: ast::MacroCall) {
        let path = match m.path().and_then(Path::from_ast) {
            Some(it) => it,
            _ => return,
        };
        let name = m.name().map(|it| it.as_name());
-        let ast_id = self.source_ast_id_map.ast_id(m);
+        let ast_id = self.source_ast_id_map.ast_id(&m);
        let export = m.has_atom_attr("macro_export");
        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export });
        self.push_item(current_module, RawItem::Macro(m));
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index bce9d2d4b..882db7681 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -47,9 +47,9 @@ pub enum PathKind {
 impl Path {
    /// Calls `cb` with all paths, represented by this use item.
-    pub fn expand_use_item<'a>(
+    pub fn expand_use_item(
-        item: &'a ast::UseItem,
+        item: &ast::UseItem,
-        mut cb: impl FnMut(Path, &'a ast::UseTree, bool, Option<Name>),
+        mut cb: impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
    ) {
        if let Some(tree) = item.use_tree() {
            expand_use_tree(None, tree, &mut cb);
@@ -57,7 +57,7 @@ impl Path {
    }
    /// 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 {
@@ -87,7 +87,7 @@ impl Path {
                    break;
                }
            }
-            path = match qualifier(path) {
+            path = match qualifier(&path) {
                Some(it) => it,
                None => break,
            };
@@ -95,7 +95,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);
            }
@@ -136,7 +136,7 @@ impl Path {
 }
 impl GenericArgs {
-    pub(crate) fn from_ast(node: &ast::TypeArgList) -> Option<GenericArgs> {
+    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
        let mut args = Vec::new();
        for type_arg in node.type_args() {
            let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
@@ -160,10 +160,10 @@ impl From<Name> for Path {
    }
 }
-fn expand_use_tree<'a>(
+fn expand_use_tree(
    prefix: Option<Path>,
-    tree: &'a ast::UseTree,
+    tree: ast::UseTree,
-    cb: &mut impl FnMut(Path, &'a ast::UseTree, bool, Option<Name>),
+    cb: &mut impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
        let prefix = match tree.path() {
@@ -188,7 +188,7 @@ fn expand_use_tree<'a>(
                if let Some(segment) = ast_path.segment() {
                    if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
                        if let Some(prefix) = prefix {
-                            cb(prefix, tree, false, alias);
+                            cb(prefix, &tree, false, alias);
                            return;
                        }
                    }
@@ -196,7 +196,7 @@ fn expand_use_tree<'a>(
            }
            if let Some(path) = convert_path(prefix, ast_path) {
                let is_glob = tree.has_star();
-                cb(path, tree, is_glob, alias)
+                cb(path, &tree, is_glob, alias)
            }
            // FIXME: report errors somewhere
            // We get here if we do
@@ -204,7 +204,7 @@ fn expand_use_tree<'a>(
    }
 }
-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 { prefix };
    let segment = path.segment()?;
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 071c1bb18..e7bc4df97 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -37,7 +37,7 @@ pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option<Mod
 pub fn module_from_declaration(
    db: &impl HirDatabase,
    file_id: FileId,
-    decl: &ast::Module,
+    decl: ast::Module,
 ) -> Option<Module> {
    let parent_module = module_from_file_id(db, file_id);
    let child_name = decl.name();
@@ -50,8 +50,8 @@ pub fn module_from_declaration(
 /// Locates the module by position in the source code.
 pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
    let parse = db.parse(position.file_id);
-    match find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
+    match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
-        Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m),
+        Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m.clone()),
        _ => module_from_file_id(db, position.file_id),
    }
 }
@@ -59,12 +59,12 @@ pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Op
 fn module_from_inline(
    db: &impl HirDatabase,
    file_id: FileId,
-    module: &ast::Module,
+    module: ast::Module,
 ) -> Option<Module> {
    assert!(!module.has_semi());
    let file_id = file_id.into();
    let ast_id_map = db.ast_id_map(file_id);
-    let item_id = ast_id_map.ast_id(module).with_file_id(file_id);
+    let item_id = ast_id_map.ast_id(&module).with_file_id(file_id);
    module_from_source(db, file_id, Some(item_id))
 }
@@ -127,16 +127,16 @@ fn try_get_resolver_for_node(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<Resolver> {
-    if let Some(module) = ast::Module::cast(node) {
+    if let Some(module) = ast::Module::cast(node.clone()) {
        Some(module_from_declaration(db, file_id, module)?.resolver(db))
-    } else if let Some(_) = ast::SourceFile::cast(node) {
+    } else if let Some(_) = ast::SourceFile::cast(node.clone()) {
        Some(module_from_source(db, file_id.into(), None)?.resolver(db))
-    } else if let Some(s) = ast::StructDef::cast(node) {
+    } else if let Some(s) = ast::StructDef::cast(node.clone()) {
        let module = module_from_child_node(db, file_id, s.syntax())?;
-        Some(struct_from_module(db, module, s).resolver(db))
+        Some(struct_from_module(db, module, &s).resolver(db))
-    } else if let Some(e) = ast::EnumDef::cast(node) {
+    } else if let Some(e) = ast::EnumDef::cast(node.clone()) {
        let module = module_from_child_node(db, file_id, e.syntax())?;
-        Some(enum_from_module(db, module, e).resolver(db))
+        Some(enum_from_module(db, module, &e).resolver(db))
    } else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
        Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
    } else {
@@ -153,14 +153,14 @@ fn def_with_body_from_child_node(
    let module = module_from_child_node(db, file_id, node)?;
    let ctx = LocationCtx::new(db, module, file_id.into());
    node.ancestors().find_map(|node| {
-        if let Some(def) = ast::FnDef::cast(node) {
+        if let Some(def) = ast::FnDef::cast(node.clone()) {
-            return Some(Function { id: ctx.to_def(def) }.into());
+            return Some(Function { id: ctx.to_def(&def) }.into());
        }
-        if let Some(def) = ast::ConstDef::cast(node) {
+        if let Some(def) = ast::ConstDef::cast(node.clone()) {
-            return Some(Const { id: ctx.to_def(def) }.into());
+            return Some(Const { id: ctx.to_def(&def) }.into());
        }
-        if let Some(def) = ast::StaticDef::cast(node) {
+        if let Some(def) = ast::StaticDef::cast(node.clone()) {
-            return Some(Static { id: ctx.to_def(def) }.into());
+            return Some(Static { id: ctx.to_def(&def) }.into());
        }
        None
    })
@@ -237,7 +237,7 @@ impl SourceAnalyzer {
            SourceAnalyzer {
                resolver: node
                    .ancestors()
-                    .find_map(|node| try_get_resolver_for_node(db, file_id, node))
+                    .find_map(|node| try_get_resolver_for_node(db, file_id, &node))
                    .unwrap_or_default(),
                body_source_map: None,
                infer: None,
@@ -257,17 +257,17 @@ impl SourceAnalyzer {
    }
    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(call.into())?;
+        let expr_id = self.body_source_map.as_ref()?.node_expr(&call.clone().into())?;
        self.infer.as_ref()?.method_resolution(expr_id)
    }
    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(field.into())?;
+        let expr_id = self.body_source_map.as_ref()?.node_expr(&field.clone().into())?;
        self.infer.as_ref()?.field_resolution(expr_id)
    }
    pub fn resolve_variant(&self, struct_lit: &ast::StructLit) -> Option<crate::VariantDef> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(struct_lit.into())?;
+        let expr_id = self.body_source_map.as_ref()?.node_expr(&struct_lit.clone().into())?;
        self.infer.as_ref()?.variant_resolution(expr_id)
    }
@@ -290,18 +290,18 @@ impl SourceAnalyzer {
    pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
        if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
-            let expr_id = self.body_source_map.as_ref()?.node_expr(path_expr.into())?;
+            let expr_id = self.body_source_map.as_ref()?.node_expr(&path_expr.into())?;
            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
                return Some(PathResolution::AssocItem(assoc));
            }
        }
        if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
-            let pat_id = self.body_source_map.as_ref()?.node_pat(path_pat.into())?;
+            let pat_id = self.body_source_map.as_ref()?.node_pat(&path_pat.into())?;
            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
                return Some(PathResolution::AssocItem(assoc));
            }
        }
-        let hir_path = crate::Path::from_ast(path)?;
+        let hir_path = crate::Path::from_ast(path.clone())?;
        let res = self.resolver.resolve_path_without_assoc_items(db, &hir_path);
        let res = res.clone().take_types().or_else(|| res.take_values())?;
        let res = match res {
@@ -343,12 +343,12 @@ impl SourceAnalyzer {
        // FIXME: at least, this should work with any DefWithBody, but ideally
        // this should be hir-based altogether
        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
-        let ptr = Either::A(AstPtr::new(pat.into()));
+        let ptr = Either::A(AstPtr::new(&ast::Pat::from(pat.clone())));
        fn_def
            .syntax()
            .descendants()
            .filter_map(ast::NameRef::cast)
-            .filter(|name_ref| match self.resolve_local_name(*name_ref) {
+            .filter(|name_ref| match self.resolve_local_name(&name_ref) {
                None => false,
                Some(entry) => entry.ptr() == ptr,
            })
@@ -411,7 +411,7 @@ fn scope_for(
    node: &SyntaxNode,
 ) -> Option<ScopeId> {
    node.ancestors()
-        .map(SyntaxNodePtr::new)
+        .map(|it| SyntaxNodePtr::new(&it))
        .filter_map(|ptr| source_map.syntax_expr(ptr))
        .find_map(|it| scopes.scope_for(it))
 }
diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs
index 6cdb90141..51cd65dda 100644
--- a/crates/ra_hir/src/source_id.rs
+++ b/crates/ra_hir/src/source_id.rs
@@ -5,7 +5,7 @@ use std::{
 };
 use ra_arena::{impl_arena_id, Arena, RawId};
-use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr, TreeArc};
+use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr};
 use crate::{AstDatabase, HirFileId};
@@ -42,9 +42,9 @@ impl<N: AstNode> AstId<N> {
        self.file_id
    }
-    pub(crate) fn to_node(&self, db: &impl AstDatabase) -> TreeArc<N> {
+    pub(crate) fn to_node(&self, db: &impl AstDatabase) -> N {
        let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.raw);
-        N::cast(&syntax_node).unwrap().to_owned()
+        N::cast(syntax_node).unwrap()
    }
 }
@@ -93,7 +93,7 @@ pub struct AstIdMap {
 impl AstIdMap {
    pub(crate) fn ast_id_map_query(db: &impl AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
        let map = if let Some(node) = db.parse_or_expand(file_id) {
-            AstIdMap::from_source(&*node)
+            AstIdMap::from_source(&node)
        } else {
            AstIdMap::default()
        };
@@ -104,9 +104,9 @@ impl AstIdMap {
        db: &impl AstDatabase,
        file_id: HirFileId,
        ast_id: ErasedFileAstId,
-    ) -> TreeArc<SyntaxNode> {
+    ) -> SyntaxNode {
        let node = db.parse_or_expand(file_id).unwrap();
-        db.ast_id_map(file_id).arena[ast_id].to_node(&*node).to_owned()
+        db.ast_id_map(file_id).arena[ast_id].to_node(&node)
    }
    pub(crate) fn ast_id<N: AstNode>(&self, item: &N) -> FileAstId<N> {
@@ -131,7 +131,7 @@ impl AstIdMap {
        // change parent's id. This means that, say, adding a new function to a
        // trait does not change ids of top-level items, which helps caching.
        bfs(node, |it| {
-            if let Some(module_item) = ast::ModuleItem::cast(it) {
+            if let Some(module_item) = ast::ModuleItem::cast(it.clone()) {
                res.alloc(module_item.syntax());
            } else if let Some(macro_call) = ast::MacroCall::cast(it) {
                res.alloc(macro_call.syntax());
@@ -146,8 +146,8 @@ impl AstIdMap {
 }
 /// Walks the subtree in bfs order, calling `f` for each node.
-fn bfs(node: &SyntaxNode, mut f: impl FnMut(&SyntaxNode)) {
+fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) {
-    let mut curr_layer = vec![node];
+    let mut curr_layer = vec![node.clone()];
    let mut next_layer = vec![];
    while !curr_layer.is_empty() {
        curr_layer.drain(..).for_each(|node| {
diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs
index fc0368303..de26f1a68 100644
--- a/crates/ra_hir/src/traits.rs
+++ b/crates/ra_hir/src/traits.rs
@@ -31,9 +31,9 @@ impl TraitData {
            item_list
                .impl_items()
                .map(|item_node| match item_node.kind() {
-                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
                })
                .collect()
        } else {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 2410602a6..265740e54 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -3086,7 +3086,7 @@ fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
    let file = db.parse(pos.file_id).ok().unwrap();
    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
    let analyzer = SourceAnalyzer::new(db, pos.file_id, expr.syntax(), Some(pos.offset));
-    let ty = analyzer.type_of(db, expr).unwrap();
+    let ty = analyzer.type_of(db, &expr).unwrap();
    ty.display(db).to_string()
 }
@@ -3126,7 +3126,7 @@ fn infer(content: &str) -> String {
        types.sort_by_key(|(ptr, _)| (ptr.range().start(), ptr.range().end()));
        for (syntax_ptr, ty) in &types {
            let node = syntax_ptr.to_node(source_file.syntax());
-            let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node) {
+            let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) {
                (self_param.self_kw_token().range(), "self".to_string())
            } else {
                (syntax_ptr.range(), node.text().to_string().replace("\n", " "))
@@ -3137,7 +3137,7 @@ fn infer(content: &str) -> String {
    for node in source_file.syntax().descendants() {
        if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
-            let analyzer = SourceAnalyzer::new(&db, file_id, node, None);
+            let analyzer = SourceAnalyzer::new(&db, file_id, &node, None);
            infer_def(analyzer.inference_result(), analyzer.body_source_map());
        }
    }
@@ -3179,7 +3179,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let node =
            algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, node, None);
+            SourceAnalyzer::new(&db, pos.file_id, &node, None);
        });
        assert!(format!("{:?}", events).contains("infer"))
    }
@@ -3200,7 +3200,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let node =
            algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, node, None);
+            SourceAnalyzer::new(&db, pos.file_id, &node, None);
        });
        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
    }
diff --git a/crates/ra_hir/src/type_ref.rs b/crates/ra_hir/src/type_ref.rs
index 8aa807648..8536ae44a 100644
--- a/crates/ra_hir/src/type_ref.rs
+++ b/crates/ra_hir/src/type_ref.rs
@@ -56,7 +56,7 @@ pub enum TypeRef {
 impl TypeRef {
    /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(node: &ast::TypeRef) -> Self {
+    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()),
@@ -95,7 +95,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_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 11dea7c14..270499612 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -11,24 +11,24 @@ use crate::{db::RootDatabase, CallInfo, FilePosition, FunctionSignature};
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
    let parse = db.parse(position.file_id);
-    let syntax = parse.tree().syntax();
+    let syntax = parse.tree().syntax().clone();
    // Find the calling expression and it's NameRef
-    let calling_node = FnCallNode::with_node(syntax, position.offset)?;
+    let calling_node = FnCallNode::with_node(&syntax, position.offset)?;
    let name_ref = calling_node.name_ref()?;
    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
-    let function = match calling_node {
+    let function = match &calling_node {
        FnCallNode::CallExpr(expr) => {
            //FIXME: apply subst
-            let (callable_def, _subst) = analyzer.type_of(db, expr.expr()?)?.as_callable()?;
+            let (callable_def, _subst) = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
            match callable_def {
                hir::CallableDef::Function(it) => it,
                //FIXME: handle other callables
                _ => return None,
            }
        }
-        FnCallNode::MethodCallExpr(expr) => analyzer.resolve_method_call(expr)?,
+        FnCallNode::MethodCallExpr(expr) => analyzer.resolve_method_call(&expr)?,
    };
    let mut call_info = CallInfo::new(db, function);
@@ -73,13 +73,13 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
    Some(call_info)
 }
-enum FnCallNode<'a> {
+enum FnCallNode {
-    CallExpr(&'a ast::CallExpr),
+    CallExpr(ast::CallExpr),
-    MethodCallExpr(&'a ast::MethodCallExpr),
+    MethodCallExpr(ast::MethodCallExpr),
 }
-impl<'a> FnCallNode<'a> {
+impl FnCallNode {
-    fn with_node(syntax: &'a SyntaxNode, offset: TextUnit) -> Option<FnCallNode<'a>> {
+    fn with_node(syntax: &SyntaxNode, offset: TextUnit) -> Option<FnCallNode> {
        if let Some(expr) = find_node_at_offset::<ast::CallExpr>(syntax, offset) {
            return Some(FnCallNode::CallExpr(expr));
        }
@@ -89,8 +89,8 @@ impl<'a> FnCallNode<'a> {
        None
    }
-    fn name_ref(&self) -> Option<&'a ast::NameRef> {
+    fn name_ref(&self) -> Option<ast::NameRef> {
-        match *self {
+        match self {
            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()?.kind() {
                ast::ExprKind::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
                _ => return None,
@@ -102,8 +102,8 @@ impl<'a> FnCallNode<'a> {
        }
    }
-    fn arg_list(&self) -> Option<&'a ast::ArgList> {
+    fn arg_list(&self) -> Option<ast::ArgList> {
-        match *self {
+        match self {
            FnCallNode::CallExpr(expr) => expr.arg_list(),
            FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
        }
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index a5f071442..536ba36df 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -5,10 +5,11 @@ use rustc_hash::FxHashSet;
 /// Complete dot accesses, i.e. fields or methods (currently only fields).
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
-    let receiver_ty = match ctx.dot_receiver.and_then(|it| ctx.analyzer.type_of(ctx.db, it)) {
+    let receiver_ty =
-        Some(it) => it,
+        match ctx.dot_receiver.as_ref().and_then(|it| ctx.analyzer.type_of(ctx.db, it)) {
-        None => return,
+            Some(it) => it,
-    };
+            None => return,
+        };
    if !ctx.is_call {
        complete_fields(acc, ctx, receiver_ty.clone());
    }
diff --git a/crates/ra_ide_api/src/completion/complete_fn_param.rs b/crates/ra_ide_api/src/completion/complete_fn_param.rs
index 5a117c485..0887ef1f6 100644
--- a/crates/ra_ide_api/src/completion/complete_fn_param.rs
+++ b/crates/ra_ide_api/src/completion/complete_fn_param.rs
@@ -20,7 +20,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
        let _ = visitor_ctx(&mut params)
            .visit::<ast::SourceFile, _>(process)
            .visit::<ast::ItemList, _>(process)
-            .accept(node);
+            .accept(&node);
    }
    params
        .into_iter()
@@ -38,10 +38,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
                .add_to(acc)
        });
-    fn process<'a, N: ast::FnDefOwner>(
+    fn process<N: ast::FnDefOwner>(node: N, params: &mut FxHashMap<String, (u32, ast::Param)>) {
-        node: &'a N,
-        params: &mut FxHashMap<String, (u32, &'a ast::Param)>,
-    ) {
        node.functions().filter_map(|it| it.param_list()).flat_map(|it| it.params()).for_each(
            |param| {
                let text = param.syntax().text().to_string();
diff --git a/crates/ra_ide_api/src/completion/complete_keyword.rs b/crates/ra_ide_api/src/completion/complete_keyword.rs
index 034ed934d..4cf34eff8 100644
--- a/crates/ra_ide_api/src/completion/complete_keyword.rs
+++ b/crates/ra_ide_api/src/completion/complete_keyword.rs
@@ -52,7 +52,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        return;
    }
-    let fn_def = match ctx.function_syntax {
+    let fn_def = match &ctx.function_syntax {
        Some(it) => it,
        None => return,
    };
@@ -65,7 +65,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        acc.add(keyword(ctx, "else", "else {$0}"));
        acc.add(keyword(ctx, "else if", "else if $0 {}"));
    }
-    if is_in_loop_body(ctx.token) {
+    if is_in_loop_body(&ctx.token) {
        if ctx.can_be_stmt {
            acc.add(keyword(ctx, "continue", "continue;"));
            acc.add(keyword(ctx, "break", "break;"));
@@ -74,19 +74,19 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
            acc.add(keyword(ctx, "break", "break"));
        }
    }
-    acc.add_all(complete_return(ctx, fn_def, ctx.can_be_stmt));
+    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
 }
-fn is_in_loop_body(leaf: SyntaxToken) -> bool {
+fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
    for node in leaf.parent().ancestors() {
        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
            break;
        }
        let loop_body = visitor()
-            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::ForExpr, _>(|it| it.loop_body())
-            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::WhileExpr, _>(|it| it.loop_body())
-            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::LoopExpr, _>(|it| it.loop_body())
-            .accept(node);
+            .accept(&node);
        if let Some(Some(body)) = loop_body {
            if leaf.range().is_subrange(&body.syntax().range()) {
                return true;
diff --git a/crates/ra_ide_api/src/completion/complete_postfix.rs b/crates/ra_ide_api/src/completion/complete_postfix.rs
index 4f5062214..c75b1c159 100644
--- a/crates/ra_ide_api/src/completion/complete_postfix.rs
+++ b/crates/ra_ide_api/src/completion/complete_postfix.rs
@@ -11,7 +11,8 @@ use ra_text_edit::TextEditBuilder;
 fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
    let edit = {
-        let receiver_range = ctx.dot_receiver.expect("no receiver available").syntax().range();
+        let receiver_range =
+            ctx.dot_receiver.as_ref().expect("no receiver available").syntax().range();
        let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
        let mut builder = TextEditBuilder::default();
        builder.replace(delete_range, snippet.to_string());
@@ -38,9 +39,9 @@ fn is_bool_or_unknown(ty: Option<Ty>) -> bool {
 }
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if let Some(dot_receiver) = ctx.dot_receiver {
+    if let Some(dot_receiver) = &ctx.dot_receiver {
        let receiver_text = dot_receiver.syntax().text().to_string();
-        let receiver_ty = ctx.analyzer.type_of(ctx.db, dot_receiver);
+        let receiver_ty = ctx.analyzer.type_of(ctx.db, &dot_receiver);
        if is_bool_or_unknown(receiver_ty) {
            postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
                .add_to(acc);
diff --git a/crates/ra_ide_api/src/completion/complete_scope.rs b/crates/ra_ide_api/src/completion/complete_scope.rs
index 1ba871257..f92034055 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -20,8 +20,8 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
                    let mut builder = TextEditBuilder::default();
                    builder.replace(ctx.source_range(), name.to_string());
                    auto_import::auto_import_text_edit(
-                        ctx.token.parent(),
+                        &ctx.token.parent(),
-                        ctx.token.parent(),
+                        &ctx.token.parent(),
                        &path,
                        &mut builder,
                    );
diff --git a/crates/ra_ide_api/src/completion/complete_struct_literal.rs b/crates/ra_ide_api/src/completion/complete_struct_literal.rs
index b6216f857..9410f740f 100644
--- a/crates/ra_ide_api/src/completion/complete_struct_literal.rs
+++ b/crates/ra_ide_api/src/completion/complete_struct_literal.rs
@@ -4,8 +4,8 @@ use crate::completion::{CompletionContext, Completions};
 /// Complete fields in fields literals.
 pub(super) fn complete_struct_literal(acc: &mut Completions, ctx: &CompletionContext) {
-    let (ty, variant) = match ctx.struct_lit_syntax.and_then(|it| {
+    let (ty, variant) = match ctx.struct_lit_syntax.as_ref().and_then(|it| {
-        Some((ctx.analyzer.type_of(ctx.db, it.into())?, ctx.analyzer.resolve_variant(it)?))
+        Some((ctx.analyzer.type_of(ctx.db, &it.clone().into())?, ctx.analyzer.resolve_variant(it)?))
    }) {
        Some(it) => it,
        _ => return,
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 4aa84751f..b803271ab 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -16,11 +16,11 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) db: &'a db::RootDatabase,
    pub(super) analyzer: hir::SourceAnalyzer,
    pub(super) offset: TextUnit,
-    pub(super) token: SyntaxToken<'a>,
+    pub(super) token: SyntaxToken,
    pub(super) module: Option<hir::Module>,
-    pub(super) function_syntax: Option<&'a ast::FnDef>,
+    pub(super) function_syntax: Option<ast::FnDef>,
-    pub(super) use_item_syntax: Option<&'a ast::UseItem>,
+    pub(super) use_item_syntax: Option<ast::UseItem>,
-    pub(super) struct_lit_syntax: Option<&'a ast::StructLit>,
+    pub(super) struct_lit_syntax: Option<ast::StructLit>,
    pub(super) is_param: bool,
    /// If a name-binding or reference to a const in a pattern.
    /// Irrefutable patterns (like let) are excluded.
@@ -35,7 +35,7 @@ pub(crate) 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<&'a ast::Expr>,
+    pub(super) dot_receiver: Option<ast::Expr>,
    /// If this is a call (method or function) in particular, i.e. the () are already there.
    pub(super) is_call: bool,
 }
@@ -50,7 +50,7 @@ impl<'a> CompletionContext<'a> {
        let token =
            find_token_at_offset(original_parse.tree().syntax(), position.offset).left_biased()?;
        let analyzer =
-            hir::SourceAnalyzer::new(db, position.file_id, token.parent(), Some(position.offset));
+            hir::SourceAnalyzer::new(db, position.file_id, &token.parent(), Some(position.offset));
        let mut ctx = CompletionContext {
            db,
            analyzer,
@@ -109,7 +109,7 @@ impl<'a> CompletionContext<'a> {
            if is_node::<ast::BindPat>(name.syntax()) {
                let bind_pat = name.syntax().ancestors().find_map(ast::BindPat::cast).unwrap();
                let parent = bind_pat.syntax().parent();
-                if parent.and_then(ast::MatchArm::cast).is_some()
+                if parent.clone().and_then(ast::MatchArm::cast).is_some()
                    || parent.and_then(ast::Condition::cast).is_some()
                {
                    self.is_pat_binding = true;
@@ -122,7 +122,7 @@ impl<'a> CompletionContext<'a> {
        }
    }
-    fn classify_name_ref(&mut self, original_file: &'a SourceFile, name_ref: &ast::NameRef) {
+    fn classify_name_ref(&mut self, original_file: SourceFile, name_ref: ast::NameRef) {
        let name_range = name_ref.syntax().range();
        if name_ref.syntax().parent().and_then(ast::NamedField::cast).is_some() {
            self.struct_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset);
@@ -153,7 +153,7 @@ impl<'a> CompletionContext<'a> {
            None => return,
        };
-        if let Some(segment) = ast::PathSegment::cast(parent) {
+        if let Some(segment) = ast::PathSegment::cast(parent.clone()) {
            let path = segment.parent_path();
            self.is_call = path
                .syntax()
@@ -162,7 +162,7 @@ impl<'a> CompletionContext<'a> {
                .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                .is_some();
-            if let Some(mut path) = hir::Path::from_ast(path) {
+            if let Some(mut path) = hir::Path::from_ast(path.clone()) {
                if !path.is_ident() {
                    path.segments.pop().unwrap();
                    self.path_prefix = Some(path);
@@ -179,7 +179,7 @@ impl<'a> CompletionContext<'a> {
                    .syntax()
                    .ancestors()
                    .find_map(|node| {
-                        if let Some(stmt) = ast::ExprStmt::cast(node) {
+                        if let Some(stmt) = ast::ExprStmt::cast(node.clone()) {
                            return Some(stmt.syntax().range() == name_ref.syntax().range());
                        }
                        if let Some(block) = ast::Block::cast(node) {
@@ -203,7 +203,7 @@ impl<'a> CompletionContext<'a> {
                }
            }
        }
-        if let Some(field_expr) = ast::FieldExpr::cast(parent) {
+        if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
            // The receiver comes before the point of insertion of the fake
            // ident, so it should have the same range in the non-modified file
            self.dot_receiver = field_expr
@@ -222,7 +222,7 @@ impl<'a> CompletionContext<'a> {
    }
 }
-fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<&N> {
+fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
    find_covering_element(syntax, range).ancestors().find_map(N::cast)
 }
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index 3f5b9e0a0..affbad6cd 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -35,8 +35,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    }));
    for node in parse.tree().syntax().descendants() {
-        check_unnecessary_braces_in_use_statement(&mut res, file_id, node);
+        check_unnecessary_braces_in_use_statement(&mut res, file_id, &node);
-        check_struct_shorthand_initialization(&mut res, file_id, node);
+        check_struct_shorthand_initialization(&mut res, file_id, &node);
    }
    let res = RefCell::new(res);
    let mut sink = DiagnosticSink::new(|d| {
@@ -60,7 +60,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    })
    .on::<hir::diagnostics::MissingFields, _>(|d| {
        let node = d.ast(db);
-        let mut ast_editor = AstEditor::new(&*node);
+        let mut ast_editor = AstEditor::new(node);
        for f in d.missed_fields.iter() {
            ast_editor.append_field(&AstBuilder::<NamedField>::from_name(f));
        }
@@ -94,11 +94,11 @@ fn check_unnecessary_braces_in_use_statement(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<()> {
-    let use_tree_list = ast::UseTreeList::cast(node)?;
+    let use_tree_list = ast::UseTreeList::cast(node.clone())?;
    if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
        let range = use_tree_list.syntax().range();
        let edit =
-            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree)
+            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(&single_use_tree)
                .unwrap_or_else(|| {
                    let to_replace = single_use_tree.syntax().text().to_string();
                    let mut edit_builder = TextEditBuilder::default();
@@ -141,7 +141,7 @@ fn check_struct_shorthand_initialization(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<()> {
-    let struct_lit = ast::StructLit::cast(node)?;
+    let struct_lit = ast::StructLit::cast(node.clone())?;
    let named_field_list = struct_lit.named_field_list()?;
    for named_field in named_field_list.fields() {
        if let (Some(name_ref), Some(expr)) = (named_field.name_ref(), named_field.expr()) {
@@ -184,7 +184,7 @@ mod tests {
        let parse = SourceFile::parse(code);
        let mut diagnostics = Vec::new();
        for node in parse.tree().syntax().descendants() {
-            func(&mut diagnostics, FileId(0), node);
+            func(&mut diagnostics, FileId(0), &node);
        }
        assert!(diagnostics.is_empty());
    }
@@ -193,7 +193,7 @@ mod tests {
        let parse = SourceFile::parse(before);
        let mut diagnostics = Vec::new();
        for node in parse.tree().syntax().descendants() {
-            func(&mut diagnostics, FileId(0), node);
+            func(&mut diagnostics, FileId(0), &node);
        }
        let diagnostic =
            diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
diff --git a/crates/ra_ide_api/src/display/function_signature.rs b/crates/ra_ide_api/src/display/function_signature.rs
index e7ad5a0d1..644a4532b 100644
--- a/crates/ra_ide_api/src/display/function_signature.rs
+++ b/crates/ra_ide_api/src/display/function_signature.rs
@@ -38,7 +38,7 @@ impl FunctionSignature {
    pub(crate) fn from_hir(db: &db::RootDatabase, function: hir::Function) -> Self {
        let doc = function.docs(db);
        let ast_node = function.source(db).ast;
-        FunctionSignature::from(&*ast_node).with_doc_opt(doc)
+        FunctionSignature::from(&ast_node).with_doc_opt(doc)
    }
 }
diff --git a/crates/ra_ide_api/src/display/navigation_target.rs b/crates/ra_ide_api/src/display/navigation_target.rs
index 20a8d418e..8cc853dd1 100644
--- a/crates/ra_ide_api/src/display/navigation_target.rs
+++ b/crates/ra_ide_api/src/display/navigation_target.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    ast::{self, DocCommentsOwner},
    AstNode, AstPtr, SmolStr,
    SyntaxKind::{self, NAME},
-    SyntaxNode, TextRange, TreeArc,
+    SyntaxNode, TextRange,
 };
 use super::short_label::ShortLabel;
@@ -169,7 +169,7 @@ impl NavigationTarget {
        let file_id = src.file_id.original_file(db);
        match src.ast {
            FieldSource::Named(it) => {
-                NavigationTarget::from_named(file_id, &*it, it.doc_comment_text(), it.short_label())
+                NavigationTarget::from_named(file_id, &it, it.doc_comment_text(), it.short_label())
            }
            FieldSource::Pos(it) => {
                NavigationTarget::from_syntax(file_id, "".into(), None, it.syntax(), None, None)
@@ -179,13 +179,13 @@ impl NavigationTarget {
    pub(crate) fn from_def_source<A, D>(db: &RootDatabase, def: D) -> NavigationTarget
    where
-        D: HasSource<Ast = TreeArc<A>>,
+        D: HasSource<Ast = A>,
        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
    {
        let src = def.source(db);
        NavigationTarget::from_named(
            src.file_id.original_file(db),
-            &*src.ast,
+            &src.ast,
            src.ast.doc_comment_text(),
            src.ast.short_label(),
        )
@@ -249,7 +249,7 @@ impl NavigationTarget {
        log::debug!("nav target {}", src.ast.syntax().debug_dump());
        NavigationTarget::from_named(
            src.file_id.original_file(db),
-            &*src.ast,
+            &src.ast,
            src.ast.doc_comment_text(),
            None,
        )
@@ -318,22 +318,18 @@ pub(crate) fn docs_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option
    let parse = db.parse(symbol.file_id);
    let node = symbol.ptr.to_node(parse.tree().syntax()).to_owned();
-    fn doc_comments<N: ast::DocCommentsOwner>(node: &N) -> Option<String> {
-        node.doc_comment_text()
-    }
    visitor()
-        .visit(doc_comments::<ast::FnDef>)
+        .visit(|it: ast::FnDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::StructDef>)
+        .visit(|it: ast::StructDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::EnumDef>)
+        .visit(|it: ast::EnumDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::TraitDef>)
+        .visit(|it: ast::TraitDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::Module>)
+        .visit(|it: ast::Module| it.doc_comment_text())
-        .visit(doc_comments::<ast::TypeAliasDef>)
+        .visit(|it: ast::TypeAliasDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::ConstDef>)
+        .visit(|it: ast::ConstDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::StaticDef>)
+        .visit(|it: ast::StaticDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::NamedFieldDef>)
+        .visit(|it: ast::NamedFieldDef| it.doc_comment_text())
-        .visit(doc_comments::<ast::EnumVariant>)
+        .visit(|it: ast::EnumVariant| it.doc_comment_text())
-        .visit(doc_comments::<ast::MacroCall>)
+        .visit(|it: ast::MacroCall| it.doc_comment_text())
        .accept(&node)?
 }
@@ -345,15 +341,15 @@ pub(crate) fn description_from_symbol(db: &RootDatabase, symbol: &FileSymbol) ->
    let node = symbol.ptr.to_node(parse.tree().syntax()).to_owned();
    visitor()
-        .visit(|node: &ast::FnDef| node.short_label())
+        .visit(|node: ast::FnDef| node.short_label())
-        .visit(|node: &ast::StructDef| node.short_label())
+        .visit(|node: ast::StructDef| node.short_label())
-        .visit(|node: &ast::EnumDef| node.short_label())
+        .visit(|node: ast::EnumDef| node.short_label())
-        .visit(|node: &ast::TraitDef| node.short_label())
+        .visit(|node: ast::TraitDef| node.short_label())
-        .visit(|node: &ast::Module| node.short_label())
+        .visit(|node: ast::Module| node.short_label())
-        .visit(|node: &ast::TypeAliasDef| node.short_label())
+        .visit(|node: ast::TypeAliasDef| node.short_label())
-        .visit(|node: &ast::ConstDef| node.short_label())
+        .visit(|node: ast::ConstDef| node.short_label())
-        .visit(|node: &ast::StaticDef| node.short_label())
+        .visit(|node: ast::StaticDef| node.short_label())
-        .visit(|node: &ast::NamedFieldDef| node.short_label())
+        .visit(|node: ast::NamedFieldDef| node.short_label())
-        .visit(|node: &ast::EnumVariant| node.short_label())
+        .visit(|node: ast::EnumVariant| node.short_label())
        .accept(&node)?
 }
diff --git a/crates/ra_ide_api/src/display/structure.rs b/crates/ra_ide_api/src/display/structure.rs
index 638484a9b..2e183d2f6 100644
--- a/crates/ra_ide_api/src/display/structure.rs
+++ b/crates/ra_ide_api/src/display/structure.rs
@@ -24,14 +24,14 @@ pub fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
    for event in file.syntax().preorder() {
        match event {
            WalkEvent::Enter(node) => {
-                if let Some(mut symbol) = structure_node(node) {
+                if let Some(mut symbol) = structure_node(&node) {
                    symbol.parent = stack.last().copied();
                    stack.push(res.len());
                    res.push(symbol);
                }
            }
            WalkEvent::Leave(node) => {
-                if structure_node(node).is_some() {
+                if structure_node(&node).is_some() {
                    stack.pop().unwrap();
                }
            }
@@ -41,19 +41,20 @@ pub fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
 }
 fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
-    fn decl<N: NameOwner + AttrsOwner>(node: &N) -> Option<StructureNode> {
+    fn decl<N: NameOwner + AttrsOwner>(node: N) -> Option<StructureNode> {
        decl_with_detail(node, None)
    }
    fn decl_with_ascription<N: NameOwner + AttrsOwner + TypeAscriptionOwner>(
-        node: &N,
+        node: N,
    ) -> Option<StructureNode> {
-        decl_with_type_ref(node, node.ascribed_type())
+        let ty = node.ascribed_type();
+        decl_with_type_ref(node, ty)
    }
    fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
-        node: &N,
+        node: N,
-        type_ref: Option<&ast::TypeRef>,
+        type_ref: Option<ast::TypeRef>,
    ) -> Option<StructureNode> {
        let detail = type_ref.map(|type_ref| {
            let mut detail = String::new();
@@ -64,7 +65,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
    }
    fn decl_with_detail<N: NameOwner + AttrsOwner>(
-        node: &N,
+        node: N,
        detail: Option<String>,
    ) -> Option<StructureNode> {
        let name = node.name()?;
@@ -82,22 +83,24 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
    fn collapse_ws(node: &SyntaxNode, output: &mut String) {
        let mut can_insert_ws = false;
-        for line in node.text().chunks().flat_map(|chunk| chunk.lines()) {
+        for chunk in node.text().chunks() {
-            let line = line.trim();
+            for line in chunk.lines() {
-            if line.is_empty() {
+                let line = line.trim();
-                if can_insert_ws {
+                if line.is_empty() {
-                    output.push_str(" ");
+                    if can_insert_ws {
-                    can_insert_ws = false;
+                        output.push_str(" ");
+                        can_insert_ws = false;
+                    }
+                } else {
+                    output.push_str(line);
+                    can_insert_ws = true;
                }
-            } else {
-                output.push_str(line);
-                can_insert_ws = true;
            }
        }
    }
    visitor()
-        .visit(|fn_def: &ast::FnDef| {
+        .visit(|fn_def: ast::FnDef| {
            let mut detail = String::from("fn");
            if let Some(type_param_list) = fn_def.type_param_list() {
                collapse_ws(type_param_list.syntax(), &mut detail);
@@ -117,11 +120,14 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
        .visit(decl::<ast::EnumVariant>)
        .visit(decl::<ast::TraitDef>)
        .visit(decl::<ast::Module>)
-        .visit(|td: &ast::TypeAliasDef| decl_with_type_ref(td, td.type_ref()))
+        .visit(|td: ast::TypeAliasDef| {
+            let ty = td.type_ref();
+            decl_with_type_ref(td, ty)
+        })
        .visit(decl_with_ascription::<ast::NamedFieldDef>)
        .visit(decl_with_ascription::<ast::ConstDef>)
        .visit(decl_with_ascription::<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 {
@@ -142,14 +148,14 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
            };
            Some(node)
        })
-        .visit(|mc: &ast::MacroCall| {
+        .visit(|mc: ast::MacroCall| {
            let first_token = mc.syntax().first_token().unwrap();
            if first_token.text().as_str() != "macro_rules" {
                return None;
            }
            decl(mc)
        })
-        .accept(node)?
+        .accept(&node)?
 }
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index 491b15702..8c49960f5 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -42,7 +42,7 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
            TokenAtOffset::None => return None,
            TokenAtOffset::Single(l) => {
                if string_kinds.contains(&l.kind()) {
-                    extend_single_word_in_comment_or_string(l, offset).unwrap_or_else(|| l.range())
+                    extend_single_word_in_comment_or_string(&l, offset).unwrap_or_else(|| l.range())
                } else {
                    l.range()
                }
@@ -56,7 +56,7 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
            if token.range() != range {
                return Some(token.range());
            }
-            if let Some(comment) = ast::Comment::cast(token) {
+            if let Some(comment) = ast::Comment::cast(token.clone()) {
                if let Some(range) = extend_comments(comment) {
                    return Some(range);
                }
@@ -73,7 +73,7 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
    let node = node.ancestors().take_while(|n| n.range() == node.range()).last().unwrap();
    if node.parent().map(|n| list_kinds.contains(&n.kind())) == Some(true) {
-        if let Some(range) = extend_list_item(node) {
+        if let Some(range) = extend_list_item(&node) {
            return Some(range);
        }
    }
@@ -82,7 +82,7 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
 }
 fn extend_single_word_in_comment_or_string(
-    leaf: SyntaxToken,
+    leaf: &SyntaxToken,
    offset: TextUnit,
 ) -> Option<TextRange> {
    let text: &str = leaf.text();
@@ -131,9 +131,9 @@ fn extend_ws(root: &SyntaxNode, ws: SyntaxToken, offset: TextUnit) -> TextRange
    ws.range()
 }
-fn pick_best<'a>(l: SyntaxToken<'a>, r: SyntaxToken<'a>) -> SyntaxToken<'a> {
+fn pick_best<'a>(l: SyntaxToken, r: SyntaxToken) -> SyntaxToken {
-    return if priority(r) > priority(l) { r } else { l };
+    return if priority(&r) > priority(&l) { r } else { l };
-    fn priority(n: SyntaxToken) -> usize {
+    fn priority(n: &SyntaxToken) -> usize {
        match n.kind() {
            WHITESPACE => 0,
            IDENT | T![self] | T![super] | T![crate] | LIFETIME => 2,
@@ -156,7 +156,7 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
                SyntaxElement::Token(it) => is_single_line_ws(it),
            })
            .next()
-            .and_then(|it| it.as_token())
+            .and_then(|it| it.as_token().cloned())
            .filter(|node| node.kind() == T![,])
    }
@@ -167,7 +167,7 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
        // Include any following whitespace when comma if after list item.
        let final_node = comma_node
            .next_sibling_or_token()
-            .and_then(|it| it.as_token())
+            .and_then(|it| it.as_token().cloned())
            .filter(|node| is_single_line_ws(node))
            .unwrap_or(comma_node);
@@ -178,8 +178,8 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
 }
 fn extend_comments(comment: ast::Comment) -> Option<TextRange> {
-    let prev = adj_comments(comment, Direction::Prev);
+    let prev = adj_comments(&comment, Direction::Prev);
-    let next = adj_comments(comment, Direction::Next);
+    let next = adj_comments(&comment, Direction::Next);
    if prev != next {
        Some(TextRange::from_to(prev.syntax().range().start(), next.syntax().range().end()))
    } else {
@@ -187,14 +187,14 @@ fn extend_comments(comment: ast::Comment) -> Option<TextRange> {
    }
 }
-fn adj_comments(comment: ast::Comment, dir: Direction) -> ast::Comment {
+fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
-    let mut res = comment;
+    let mut res = comment.clone();
    for element in comment.syntax().siblings_with_tokens(dir) {
        let token = match element.as_token() {
            None => break,
            Some(token) => token,
        };
-        if let Some(c) = ast::Comment::cast(token) {
+        if let Some(c) = ast::Comment::cast(token.clone()) {
            res = c
        } else if token.kind() != WHITESPACE || token.text().contains("\n\n") {
            break;
diff --git a/crates/ra_ide_api/src/folding_ranges.rs b/crates/ra_ide_api/src/folding_ranges.rs
index 9d4855a64..c2b981aed 100644
--- a/crates/ra_ide_api/src/folding_ranges.rs
+++ b/crates/ra_ide_api/src/folding_ranges.rs
@@ -30,7 +30,7 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
    for element in file.syntax().descendants_with_tokens() {
        // Fold items that span multiple lines
        if let Some(kind) = fold_kind(element.kind()) {
-            let is_multiline = match element {
+            let is_multiline = match &element {
                SyntaxElement::Node(node) => node.text().contains('\n'),
                SyntaxElement::Token(token) => token.text().contains('\n'),
            };
@@ -56,7 +56,7 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
            SyntaxElement::Node(node) => {
                // Fold groups of imports
                if node.kind() == USE_ITEM && !visited_imports.contains(&node) {
-                    if let Some(range) = contiguous_range_for_group(node, &mut visited_imports) {
+                    if let Some(range) = contiguous_range_for_group(&node, &mut visited_imports) {
                        res.push(Fold { range, kind: FoldKind::Imports })
                    }
                }
@@ -65,7 +65,7 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                if node.kind() == MODULE && !has_visibility(&node) && !visited_mods.contains(&node)
                {
                    if let Some(range) =
-                        contiguous_range_for_group_unless(node, has_visibility, &mut visited_mods)
+                        contiguous_range_for_group_unless(&node, has_visibility, &mut visited_mods)
                    {
                        res.push(Fold { range, kind: FoldKind::Mods })
                    }
@@ -88,24 +88,24 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
 }
 fn has_visibility(node: &SyntaxNode) -> bool {
-    ast::Module::cast(node).and_then(|m| m.visibility()).is_some()
+    ast::Module::cast(node.clone()).and_then(|m| m.visibility()).is_some()
 }
-fn contiguous_range_for_group<'a>(
+fn contiguous_range_for_group(
-    first: &'a SyntaxNode,
+    first: &SyntaxNode,
-    visited: &mut FxHashSet<&'a SyntaxNode>,
+    visited: &mut FxHashSet<SyntaxNode>,
 ) -> Option<TextRange> {
    contiguous_range_for_group_unless(first, |_| false, visited)
 }
-fn contiguous_range_for_group_unless<'a>(
+fn contiguous_range_for_group_unless(
-    first: &'a SyntaxNode,
+    first: &SyntaxNode,
-    unless: impl Fn(&'a SyntaxNode) -> bool,
+    unless: impl Fn(&SyntaxNode) -> bool,
-    visited: &mut FxHashSet<&'a SyntaxNode>,
+    visited: &mut FxHashSet<SyntaxNode>,
 ) -> Option<TextRange> {
-    visited.insert(first);
+    visited.insert(first.clone());
-    let mut last = first;
+    let mut last = first.clone();
    for element in first.siblings_with_tokens(Direction::Next) {
        let node = match element {
            SyntaxElement::Token(token) => {
@@ -123,15 +123,15 @@ fn contiguous_range_for_group_unless<'a>(
        };
        // Stop if we find a node that doesn't belong to the group
-        if node.kind() != first.kind() || unless(node) {
+        if node.kind() != first.kind() || unless(&node) {
            break;
        }
-        visited.insert(node);
+        visited.insert(node.clone());
        last = node;
    }
-    if first != last {
+    if first != &last {
        Some(TextRange::from_to(first.range().start(), last.range().end()))
    } else {
        // The group consists of only one element, therefore it cannot be folded
@@ -139,11 +139,11 @@ fn contiguous_range_for_group_unless<'a>(
    }
 }
-fn contiguous_range_for_comment<'a>(
+fn contiguous_range_for_comment(
-    first: ast::Comment<'a>,
+    first: ast::Comment,
-    visited: &mut FxHashSet<ast::Comment<'a>>,
+    visited: &mut FxHashSet<ast::Comment>,
 ) -> Option<TextRange> {
-    visited.insert(first);
+    visited.insert(first.clone());
    // Only fold comments of the same flavor
    let group_kind = first.kind();
@@ -151,11 +151,11 @@ fn contiguous_range_for_comment<'a>(
        return None;
    }
-    let mut last = first;
+    let mut last = first.clone();
    for element in first.syntax().siblings_with_tokens(Direction::Next) {
        match element {
            SyntaxElement::Token(token) => {
-                if let Some(ws) = ast::Whitespace::cast(token) {
+                if let Some(ws) = ast::Whitespace::cast(token.clone()) {
                    if !ws.spans_multiple_lines() {
                        // Ignore whitespace without blank lines
                        continue;
@@ -163,7 +163,7 @@ fn contiguous_range_for_comment<'a>(
                }
                if let Some(c) = ast::Comment::cast(token) {
                    if c.kind() == group_kind {
-                        visited.insert(c);
+                        visited.insert(c.clone());
                        last = c;
                        continue;
                    }
@@ -193,7 +193,7 @@ mod tests {
    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
        let (ranges, text) = extract_ranges(text, "fold");
        let parse = SourceFile::parse(&text);
-        let folds = folding_ranges(parse.tree());
+        let folds = folding_ranges(&parse.tree());
        assert_eq!(
            folds.len(),
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 1066bf155..82b5e3b5e 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -20,13 +20,13 @@ pub(crate) fn goto_definition(
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
    let parse = db.parse(position.file_id);
-    let syntax = parse.tree().syntax();
+    let syntax = parse.tree().syntax().clone();
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&syntax, position.offset) {
-        let navs = reference_definition(db, position.file_id, name_ref).to_vec();
+        let navs = reference_definition(db, position.file_id, &name_ref).to_vec();
        return Some(RangeInfo::new(name_ref.syntax().range(), navs.to_vec()));
    }
-    if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
+    if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
-        let navs = name_definition(db, position.file_id, name)?;
+        let navs = name_definition(db, position.file_id, &name)?;
        return Some(RangeInfo::new(name.syntax().range(), navs));
    }
    None
@@ -94,7 +94,7 @@ pub(crate) fn name_definition(
 ) -> Option<Vec<NavigationTarget>> {
    let parent = name.syntax().parent()?;
-    if let Some(module) = ast::Module::cast(&parent) {
+    if let Some(module) = ast::Module::cast(parent.clone()) {
        if module.has_semi() {
            if let Some(child_module) =
                hir::source_binder::module_from_declaration(db, file_id, module)
@@ -114,38 +114,88 @@ pub(crate) fn name_definition(
 fn named_target(file_id: FileId, node: &SyntaxNode) -> Option<NavigationTarget> {
    visitor()
-        .visit(|node: &ast::StructDef| {
+        .visit(|node: ast::StructDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::EnumDef| {
+        .visit(|node: ast::EnumDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::EnumVariant| {
+        .visit(|node: ast::EnumVariant| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::FnDef| {
+        .visit(|node: ast::FnDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::TypeAliasDef| {
+        .visit(|node: ast::TypeAliasDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::ConstDef| {
+        .visit(|node: ast::ConstDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::StaticDef| {
+        .visit(|node: ast::StaticDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::TraitDef| {
+        .visit(|node: ast::TraitDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::NamedFieldDef| {
+        .visit(|node: ast::NamedFieldDef| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::Module| {
+        .visit(|node: ast::Module| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), node.short_label())
+            NavigationTarget::from_named(
+                file_id,
+                &node,
+                node.doc_comment_text(),
+                node.short_label(),
+            )
        })
-        .visit(|node: &ast::MacroCall| {
+        .visit(|node: ast::MacroCall| {
-            NavigationTarget::from_named(file_id, node, node.doc_comment_text(), None)
+            NavigationTarget::from_named(file_id, &node, node.doc_comment_text(), None)
        })
        .accept(node)
 }
diff --git a/crates/ra_ide_api/src/goto_type_definition.rs b/crates/ra_ide_api/src/goto_type_definition.rs
index 6ce5e214f..fc4b6e1af 100644
--- a/crates/ra_ide_api/src/goto_type_definition.rs
+++ b/crates/ra_ide_api/src/goto_type_definition.rs
@@ -13,15 +13,17 @@ pub(crate) fn goto_type_definition(
        token
            .parent()
            .ancestors()
-            .find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())
+            .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())
    })?;
-    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, node, None);
+    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, &node, None);
-    let ty: hir::Ty = if let Some(ty) = ast::Expr::cast(node).and_then(|e| analyzer.type_of(db, e))
+    let ty: hir::Ty = if let Some(ty) =
+        ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
    {
        ty
-    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, p)) {
+    } else if let Some(ty) = ast::Pat::cast(node.clone()).and_then(|p| analyzer.type_of_pat(db, &p))
+    {
        ty
    } else {
        return None;
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 253d21f48..e503bf6a9 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -6,7 +6,7 @@ use ra_syntax::{
        visit::{visitor, Visitor},
    },
    ast::{self, DocCommentsOwner},
-    AstNode, TreeArc,
+    AstNode,
 };
 use crate::{
@@ -104,7 +104,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
        let mut no_fallback = false;
-        match classify_name_ref(db, &analyzer, name_ref) {
+        match classify_name_ref(db, &analyzer, &name_ref) {
            Some(Method(it)) => res.extend(from_def_source(db, it)),
            Some(Macro(it)) => {
                let src = it.source(db);
@@ -163,7 +163,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
        if res.is_empty() && !no_fallback {
            // Fallback index based approach:
-            let symbols = crate::symbol_index::index_resolve(db, name_ref);
+            let symbols = crate::symbol_index::index_resolve(db, &name_ref);
            for sym in symbols {
                let docs = docs_from_symbol(db, &sym);
                let desc = description_from_symbol(db, &sym);
@@ -177,34 +177,32 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    } else if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
        if let Some(parent) = name.syntax().parent() {
            let text = visitor()
-                .visit(|node: &ast::StructDef| {
+                .visit(|node: ast::StructDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::EnumDef| {
+                .visit(|node: ast::EnumDef| hover_text(node.doc_comment_text(), node.short_label()))
+                .visit(|node: ast::EnumVariant| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::EnumVariant| {
+                .visit(|node: ast::FnDef| hover_text(node.doc_comment_text(), node.short_label()))
+                .visit(|node: ast::TypeAliasDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::FnDef| hover_text(node.doc_comment_text(), node.short_label()))
+                .visit(|node: ast::ConstDef| {
-                .visit(|node: &ast::TypeAliasDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::ConstDef| {
+                .visit(|node: ast::StaticDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::StaticDef| {
+                .visit(|node: ast::TraitDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::TraitDef| {
+                .visit(|node: ast::NamedFieldDef| {
                    hover_text(node.doc_comment_text(), node.short_label())
                })
-                .visit(|node: &ast::NamedFieldDef| {
+                .visit(|node: ast::Module| hover_text(node.doc_comment_text(), node.short_label()))
-                    hover_text(node.doc_comment_text(), node.short_label())
+                .visit(|node: ast::MacroCall| hover_text(node.doc_comment_text(), None))
-                })
+                .accept(&parent);
-                .visit(|node: &ast::Module| hover_text(node.doc_comment_text(), node.short_label()))
-                .visit(|node: &ast::MacroCall| hover_text(node.doc_comment_text(), None))
-                .accept(parent);
            if let Some(text) = text {
                res.extend(text);
@@ -217,8 +215,9 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    }
    if range.is_none() {
-        let node = ancestors_at_offset(file.syntax(), position.offset)
+        let node = ancestors_at_offset(file.syntax(), position.offset).find(|n| {
-            .find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())?;
+            ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some()
+        })?;
        let frange = FileRange { file_id: position.file_id, range: node.range() };
        res.extend(type_of(db, frange).map(rust_code_markup));
        range = Some(node.range());
@@ -233,7 +232,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    fn from_def_source<A, D>(db: &RootDatabase, def: D) -> Option<String>
    where
-        D: HasSource<Ast = TreeArc<A>>,
+        D: HasSource<Ast = A>,
        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
    {
        let src = def.source(db);
@@ -243,17 +242,17 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
    let parse = db.parse(frange.file_id);
-    let syntax = parse.tree().syntax();
+    let leaf_node = find_covering_element(parse.tree().syntax(), frange.range);
-    let leaf_node = find_covering_element(syntax, frange.range);
    // if we picked identifier, expand to pattern/expression
    let node = leaf_node
        .ancestors()
        .take_while(|it| it.range() == leaf_node.range())
-        .find(|&it| ast::Expr::cast(it).is_some() || ast::Pat::cast(it).is_some())?;
+        .find(|it| ast::Expr::cast(it.clone()).is_some() || ast::Pat::cast(it.clone()).is_some())?;
-    let analyzer = hir::SourceAnalyzer::new(db, frange.file_id, node, None);
+    let analyzer = hir::SourceAnalyzer::new(db, frange.file_id, &node, None);
-    let ty = if let Some(ty) = ast::Expr::cast(node).and_then(|e| analyzer.type_of(db, e)) {
+    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
+    {
        ty
-    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, p)) {
+    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, &p)) {
        ty
    } else {
        return None;
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
index 6d69f36aa..15999d433 100644
--- a/crates/ra_ide_api/src/impls.rs
+++ b/crates/ra_ide_api/src/impls.rs
@@ -9,19 +9,19 @@ pub(crate) fn goto_implementation(
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
    let parse = db.parse(position.file_id);
-    let syntax = parse.tree().syntax();
+    let syntax = parse.tree().syntax().clone();
    let module = source_binder::module_from_position(db, position)?;
-    if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(syntax, position.offset) {
+    if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            nominal_def.syntax().range(),
-            impls_for_def(db, nominal_def, module)?,
+            impls_for_def(db, &nominal_def, module)?,
        ));
-    } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(syntax, position.offset) {
+    } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            trait_def.syntax().range(),
-            impls_for_trait(db, trait_def, module)?,
+            impls_for_trait(db, &trait_def, module)?,
        ));
    }
diff --git a/crates/ra_ide_api/src/join_lines.rs b/crates/ra_ide_api/src/join_lines.rs
index e20cb1370..50bcfb5b7 100644
--- a/crates/ra_ide_api/src/join_lines.rs
+++ b/crates/ra_ide_api/src/join_lines.rs
@@ -27,7 +27,7 @@ pub fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
        SyntaxElement::Token(token) => token.parent(),
    };
    let mut edit = TextEditBuilder::default();
-    for token in node.descendants_with_tokens().filter_map(|it| it.as_token()) {
+    for token in node.descendants_with_tokens().filter_map(|it| it.as_token().cloned()) {
        let range = match range.intersection(&token.range()) {
            Some(range) => range,
            None => continue,
@@ -37,7 +37,7 @@ pub fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
            let pos: TextUnit = (pos as u32).into();
            let off = token.range().start() + range.start() + pos;
            if !edit.invalidates_offset(off) {
-                remove_newline(&mut edit, token, off);
+                remove_newline(&mut edit, &token, off);
            }
        }
    }
@@ -45,7 +45,7 @@ pub fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
    edit.finish()
 }
-fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUnit) {
+fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextUnit) {
    if token.kind() != WHITESPACE || token.text().bytes().filter(|&b| b == b'\n').count() != 1 {
        // The node is either the first or the last in the file
        let suff = &token.text()[TextRange::from_to(
@@ -98,9 +98,10 @@ fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUn
            TextRange::from_to(prev.range().start(), token.range().end()),
            space.to_string(),
        );
-    } else if let (Some(_), Some(next)) =
+    } else if let (Some(_), Some(next)) = (
-        (prev.as_token().and_then(ast::Comment::cast), next.as_token().and_then(ast::Comment::cast))
+        prev.as_token().cloned().and_then(ast::Comment::cast),
-    {
+        next.as_token().cloned().and_then(ast::Comment::cast),
+    ) {
        // Removes: newline (incl. surrounding whitespace), start of the next comment
        edit.delete(TextRange::from_to(
            token.range().start(),
@@ -113,16 +114,16 @@ fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUn
 }
 fn has_comma_after(node: &SyntaxNode) -> bool {
-    match non_trivia_sibling(node.into(), Direction::Next) {
+    match non_trivia_sibling(node.clone().into(), Direction::Next) {
        Some(n) => n.kind() == T![,],
        _ => false,
    }
 }
-fn join_single_expr_block(edit: &mut TextEditBuilder, token: SyntaxToken) -> Option<()> {
+fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
    let block = ast::Block::cast(token.parent())?;
    let block_expr = ast::BlockExpr::cast(block.syntax().parent()?)?;
-    let expr = extract_trivial_expression(block)?;
+    let expr = extract_trivial_expression(&block)?;
    let block_range = block_expr.syntax().range();
    let mut buf = expr.syntax().text().to_string();
@@ -139,7 +140,7 @@ fn join_single_expr_block(edit: &mut TextEditBuilder, token: SyntaxToken) -> Opt
    Some(())
 }
-fn join_single_use_tree(edit: &mut TextEditBuilder, token: SyntaxToken) -> Option<()> {
+fn join_single_use_tree(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
    let use_tree_list = ast::UseTreeList::cast(token.parent())?;
    let (tree,) = use_tree_list.use_trees().collect_tuple()?;
    edit.replace(use_tree_list.syntax().range(), tree.syntax().text().to_string());
@@ -504,7 +505,7 @@ fn foo() {
    fn check_join_lines_sel(before: &str, after: &str) {
        let (sel, before) = extract_range(before);
        let parse = SourceFile::parse(&before);
-        let result = join_lines(parse.tree(), sel);
+        let result = join_lines(&parse.tree(), sel);
        let actual = result.apply(&before);
        assert_eq_text!(after, &actual);
    }
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 9f3b18d9d..c54d574bc 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -50,7 +50,7 @@ use ra_db::{
    salsa::{self, ParallelDatabase},
    CheckCanceled, SourceDatabase,
 };
-use ra_syntax::{SourceFile, TextRange, TextUnit, TreeArc};
+use ra_syntax::{SourceFile, TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 use relative_path::RelativePathBuf;
@@ -325,8 +325,8 @@ impl Analysis {
    }
    /// Gets the syntax tree of the file.
-    pub fn parse(&self, file_id: FileId) -> TreeArc<SourceFile> {
+    pub fn parse(&self, file_id: FileId) -> SourceFile {
-        self.db.parse(file_id).tree().to_owned()
+        self.db.parse(file_id).tree()
    }
    /// Gets the file's `LineIndex`: data structure to convert between absolute
@@ -360,7 +360,7 @@ impl Analysis {
        let parse = self.db.parse(frange.file_id);
        let file_edit = SourceFileEdit {
            file_id: frange.file_id,
-            edit: join_lines::join_lines(parse.tree(), frange.range),
+            edit: join_lines::join_lines(&parse.tree(), frange.range),
        };
        SourceChange::source_file_edit("join lines", file_edit)
    }
@@ -393,13 +393,13 @@ impl Analysis {
    /// file outline.
    pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
        let parse = self.db.parse(file_id);
-        file_structure(parse.tree())
+        file_structure(&parse.tree())
    }
    /// Returns the set of folding ranges.
    pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
        let parse = self.db.parse(file_id);
-        folding_ranges::folding_ranges(parse.tree())
+        folding_ranges::folding_ranges(&parse.tree())
    }
    /// Fuzzy searches for a symbol.
diff --git a/crates/ra_ide_api/src/matching_brace.rs b/crates/ra_ide_api/src/matching_brace.rs
index 455a5c891..102327fd7 100644
--- a/crates/ra_ide_api/src/matching_brace.rs
+++ b/crates/ra_ide_api/src/matching_brace.rs
@@ -26,7 +26,7 @@ mod tests {
        fn do_check(before: &str, after: &str) {
            let (pos, before) = extract_offset(before);
            let parse = SourceFile::parse(&before);
-            let new_pos = match matching_brace(parse.tree(), pos) {
+            let new_pos = match matching_brace(&parse.tree(), pos) {
                None => pos,
                Some(pos) => pos,
            };
diff --git a/crates/ra_ide_api/src/name_ref_kind.rs b/crates/ra_ide_api/src/name_ref_kind.rs
index 67381c9c8..6832acf5d 100644
--- a/crates/ra_ide_api/src/name_ref_kind.rs
+++ b/crates/ra_ide_api/src/name_ref_kind.rs
@@ -26,7 +26,7 @@ pub(crate) fn classify_name_ref(
    // Check if it is a method
    if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
        tested_by!(goto_definition_works_for_methods);
-        if let Some(func) = analyzer.resolve_method_call(method_call) {
+        if let Some(func) = analyzer.resolve_method_call(&method_call) {
            return Some(Method(func));
        }
    }
@@ -40,7 +40,7 @@ pub(crate) fn classify_name_ref(
        .and_then(ast::MacroCall::cast)
    {
        tested_by!(goto_definition_works_for_macros);
-        if let Some(mac) = analyzer.resolve_macro_call(db, macro_call) {
+        if let Some(mac) = analyzer.resolve_macro_call(db, &macro_call) {
            return Some(Macro(mac));
        }
    }
@@ -48,7 +48,7 @@ pub(crate) fn classify_name_ref(
    // It could also be a field access
    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
        tested_by!(goto_definition_works_for_fields);
-        if let Some(field) = analyzer.resolve_field(field_expr) {
+        if let Some(field) = analyzer.resolve_field(&field_expr) {
            return Some(FieldAccess(field));
        };
    }
@@ -59,7 +59,7 @@ pub(crate) fn classify_name_ref(
        let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
-        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, lit.into())) {
+        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, &lit.into())) {
            if let Some((hir::AdtDef::Struct(s), _)) = ty.as_adt() {
                let hir_path = hir::Path::from_name_ref(name_ref);
                let hir_name = hir_path.as_ident().unwrap();
@@ -73,7 +73,7 @@ pub(crate) fn classify_name_ref(
    // General case, a path or a local:
    if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
-        if let Some(resolved) = analyzer.resolve_path(db, path) {
+        if let Some(resolved) = analyzer.resolve_path(db, &path) {
            return match resolved {
                hir::PathResolution::Def(def) => Some(Def(def)),
                hir::PathResolution::LocalBinding(Either::A(pat)) => Some(Pat(pat)),
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 0af1ae811..1c4cd49dc 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -50,11 +50,11 @@ pub(crate) fn find_all_refs(
    position: FilePosition,
 ) -> Option<ReferenceSearchResult> {
    let parse = db.parse(position.file_id);
-    let (binding, analyzer) = find_binding(db, parse.tree(), position)?;
+    let (binding, analyzer) = find_binding(db, &parse.tree(), position)?;
-    let declaration = NavigationTarget::from_bind_pat(position.file_id, binding);
+    let declaration = NavigationTarget::from_bind_pat(position.file_id, &binding);
    let references = analyzer
-        .find_all_refs(binding)
+        .find_all_refs(&binding)
        .into_iter()
        .map(move |ref_desc| FileRange { file_id: position.file_id, range: ref_desc.range })
        .collect::<Vec<_>>();
@@ -63,9 +63,9 @@ pub(crate) fn find_all_refs(
    fn find_binding<'a>(
        db: &RootDatabase,
-        source_file: &'a SourceFile,
+        source_file: &SourceFile,
        position: FilePosition,
-    ) -> Option<(&'a ast::BindPat, hir::SourceAnalyzer)> {
+    ) -> Option<(ast::BindPat, hir::SourceAnalyzer)> {
        let syntax = source_file.syntax();
        if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
            let analyzer = hir::SourceAnalyzer::new(db, position.file_id, binding.syntax(), None);
@@ -73,7 +73,7 @@ pub(crate) fn find_all_refs(
        };
        let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
        let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
-        let resolved = analyzer.resolve_local_name(name_ref)?;
+        let resolved = analyzer.resolve_local_name(&name_ref)?;
        if let Either::A(ptr) = resolved.ptr() {
            if let ast::PatKind::BindPat(binding) = ptr.to_node(source_file.syntax()).kind() {
                return Some((binding, analyzer));
@@ -89,10 +89,10 @@ pub(crate) fn rename(
    new_name: &str,
 ) -> Option<SourceChange> {
    let parse = db.parse(position.file_id);
-    let syntax = parse.tree().syntax();
+    if let Some((ast_name, ast_module)) =
+        find_name_and_module_at_offset(parse.tree().syntax(), position)
-    if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
+    {
-        rename_mod(db, ast_name, ast_module, position, new_name)
+        rename_mod(db, &ast_name, &ast_module, position, new_name)
    } else {
        rename_reference(db, position, new_name)
    }
@@ -101,14 +101,10 @@ pub(crate) fn rename(
 fn find_name_and_module_at_offset(
    syntax: &SyntaxNode,
    position: FilePosition,
-) -> Option<(&ast::Name, &ast::Module)> {
+) -> Option<(ast::Name, ast::Module)> {
-    let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset);
+    let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
-    let ast_name_parent = ast::Module::cast(ast_name?.syntax().parent()?);
+    let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
+    Some((ast_name, ast_module))
-    if let (Some(ast_module), Some(name)) = (ast_name_parent, ast_name) {
-        return Some((name, ast_module));
-    }
-    None
 }
 fn source_edit_from_fileid_range(
@@ -135,7 +131,8 @@ fn rename_mod(
 ) -> Option<SourceChange> {
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
-    if let Some(module) = source_binder::module_from_declaration(db, position.file_id, &ast_module)
+    if let Some(module) =
+        source_binder::module_from_declaration(db, position.file_id, ast_module.clone())
    {
        let src = module.definition_source(db);
        let file_id = src.file_id.as_original_file();
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 8cb859b37..200958434 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -26,8 +26,8 @@ pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
    parse.tree().syntax().descendants().filter_map(|i| runnable(db, file_id, i)).collect()
 }
-fn runnable(db: &RootDatabase, file_id: FileId, item: &SyntaxNode) -> Option<Runnable> {
+fn runnable(db: &RootDatabase, file_id: FileId, item: SyntaxNode) -> Option<Runnable> {
-    if let Some(fn_def) = ast::FnDef::cast(item) {
+    if let Some(fn_def) = ast::FnDef::cast(item.clone()) {
        runnable_fn(fn_def)
    } else if let Some(m) = ast::Module::cast(item) {
        runnable_mod(db, file_id, m)
@@ -36,8 +36,8 @@ fn runnable(db: &RootDatabase, file_id: FileId, item: &SyntaxNode) -> Option<Run
    }
 }
-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 name = fn_def.name()?.text().clone();
    let kind = if name == "main" {
        RunnableKind::Bin
    } else if fn_def.has_atom_attr("test") {
@@ -50,7 +50,7 @@ fn runnable_fn(fn_def: &ast::FnDef) -> Option<Runnable> {
    Some(Runnable { range: fn_def.syntax().range(), kind })
 }
-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()
diff --git a/crates/ra_ide_api/src/status.rs b/crates/ra_ide_api/src/status.rs
index a31e15245..d533d1742 100644
--- a/crates/ra_ide_api/src/status.rs
+++ b/crates/ra_ide_api/src/status.rs
@@ -104,7 +104,7 @@ impl FromIterator<TableEntry<MacroFile, Option<Parse<SyntaxNode>>>> for SyntaxTr
        let mut res = SyntaxTreeStats::default();
        for entry in iter {
            res.total += 1;
-            if let Some(tree) = entry.value.and_then(|it| it).map(|it| it.tree().to_owned()) {
+            if let Some(tree) = entry.value.and_then(|it| it).map(|it| it.syntax_node()) {
                res.retained += 1;
                res.retained_size += tree.memory_size_of_subtree();
            }
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
index 9b3a45319..e784b5f69 100644
--- a/crates/ra_ide_api/src/symbol_index.rs
+++ b/crates/ra_ide_api/src/symbol_index.rs
@@ -61,7 +61,7 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
    db.check_canceled();
    let parse = db.parse(file_id);
-    let symbols = source_file_to_file_symbols(parse.tree(), file_id);
+    let symbols = source_file_to_file_symbols(&parse.tree(), file_id);
    // FIXME: add macros here
@@ -173,7 +173,7 @@ impl SymbolIndex {
        files: impl ParallelIterator<Item = (FileId, Parse<ast::SourceFile>)>,
    ) -> SymbolIndex {
        let symbols = files
-            .flat_map(|(file_id, file)| source_file_to_file_symbols(file.tree(), file_id))
+            .flat_map(|(file_id, file)| source_file_to_file_symbols(&file.tree(), file_id))
            .collect::<Vec<_>>();
        SymbolIndex::new(symbols)
    }
@@ -249,7 +249,7 @@ fn source_file_to_file_symbols(source_file: &SourceFile, file_id: FileId) -> Vec
    for event in source_file.syntax().preorder() {
        match event {
            WalkEvent::Enter(node) => {
-                if let Some(mut symbol) = to_file_symbol(node, file_id) {
+                if let Some(mut symbol) = to_file_symbol(&node, file_id) {
                    symbol.container_name = stack.last().cloned();
                    stack.push(symbol.name.clone());
@@ -258,7 +258,7 @@ fn source_file_to_file_symbols(source_file: &SourceFile, file_id: FileId) -> Vec
            }
            WalkEvent::Leave(node) => {
-                if to_symbol(node).is_some() {
+                if to_symbol(&node).is_some() {
                    stack.pop();
                }
            }
@@ -269,7 +269,7 @@ fn source_file_to_file_symbols(source_file: &SourceFile, file_id: FileId) -> Vec
 }
 fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
-    fn decl<N: NameOwner>(node: &N) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
+    fn decl<N: NameOwner>(node: N) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
        let name = node.name()?;
        let name_range = name.syntax().range();
        let name = name.text().clone();
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index eb392d5da..16a728789 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -31,8 +31,8 @@ fn is_control_keyword(kind: SyntaxKind) -> bool {
    }
 }
-fn is_variable_mutable(db: &RootDatabase, analyzer: &hir::SourceAnalyzer, pat: &ast::Pat) -> bool {
+fn is_variable_mutable(db: &RootDatabase, analyzer: &hir::SourceAnalyzer, pat: ast::Pat) -> bool {
-    let ty = analyzer.type_of_pat(db, pat).unwrap_or(Ty::Unknown);
+    let ty = analyzer.type_of_pat(db, &pat).unwrap_or(Ty::Unknown);
    let is_ty_mut = {
        if let Some((_, mutability)) = ty.as_reference() {
            match mutability {
@@ -55,7 +55,7 @@ fn is_variable_mutable(db: &RootDatabase, analyzer: &hir::SourceAnalyzer, pat: &
 pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
    let _p = profile("highlight");
    let parse = db.parse(file_id);
-    let root = parse.tree().syntax();
+    let root = parse.tree().syntax().clone();
    fn calc_binding_hash(file_id: FileId, text: &SmolStr, shadow_count: u32) -> u64 {
        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
@@ -70,6 +70,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
    }
    // Visited nodes to handle highlighting priorities
+    // FIXME: retain only ranges here
    let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default();
    let mut bindings_shadow_count: FxHashMap<SmolStr, u32> = FxHashMap::default();
@@ -84,14 +85,14 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
            ATTR => "attribute",
            NAME_REF => {
-                if let Some(name_ref) = node.as_node().and_then(ast::NameRef::cast) {
+                if let Some(name_ref) = node.as_node().cloned().and_then(ast::NameRef::cast) {
                    // FIXME: revisit this after #1340
                    use crate::name_ref_kind::{classify_name_ref, NameRefKind::*};
                    use hir::{ImplItem, ModuleDef};
                    // FIXME: try to reuse the SourceAnalyzers
                    let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
-                    match classify_name_ref(db, &analyzer, name_ref) {
+                    match classify_name_ref(db, &analyzer, &name_ref) {
                        Some(Method(_)) => "function",
                        Some(Macro(_)) => "macro",
                        Some(FieldAccess(_)) => "field",
@@ -113,13 +114,13 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                        Some(Pat(ptr)) => {
                            binding_hash = Some({
                                let text =
-                                    ptr.syntax_node_ptr().to_node(root).text().to_smol_string();
+                                    ptr.syntax_node_ptr().to_node(&root).text().to_smol_string();
                                let shadow_count =
                                    bindings_shadow_count.entry(text.clone()).or_default();
                                calc_binding_hash(file_id, &text, *shadow_count)
                            });
-                            if is_variable_mutable(db, &analyzer, ptr.to_node(root)) {
+                            if is_variable_mutable(db, &analyzer, ptr.to_node(&root)) {
                                "variable.mut"
                            } else {
                                "variable"
@@ -134,7 +135,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                }
            }
            NAME => {
-                if let Some(name) = node.as_node().and_then(ast::Name::cast) {
+                if let Some(name) = node.as_node().cloned().and_then(ast::Name::cast) {
                    let analyzer = hir::SourceAnalyzer::new(db, file_id, name.syntax(), None);
                    if let Some(pat) = name.syntax().ancestors().find_map(ast::Pat::cast) {
                        binding_hash = Some({
@@ -176,12 +177,11 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
            k if is_control_keyword(k) => "keyword.control",
            k if k.is_keyword() => "keyword",
            _ => {
-                // let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+                if let Some(macro_call) = node.as_node().cloned().and_then(ast::MacroCall::cast) {
-                if let Some(macro_call) = node.as_node().and_then(ast::MacroCall::cast) {
                    if let Some(path) = macro_call.path() {
                        if let Some(segment) = path.segment() {
                            if let Some(name_ref) = segment.name_ref() {
-                                highlighted.insert(name_ref.syntax().into());
+                                highlighted.insert(name_ref.syntax().clone().into());
                                let range_start = name_ref.syntax().range().start();
                                let mut range_end = name_ref.syntax().range().end();
                                for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
@@ -230,7 +230,8 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
    let mut buf = String::new();
    buf.push_str(&STYLE);
    buf.push_str("<pre><code>");
-    let tokens = parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.as_token());
+    let tokens =
+        parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.as_token().cloned());
    for token in tokens {
        could_intersect.retain(|it| token.range().start() <= it.range.end());
        while let Some(r) = ranges.get(frontier) {
diff --git a/crates/ra_ide_api/src/syntax_tree.rs b/crates/ra_ide_api/src/syntax_tree.rs
index b3e08c041..3d7373d02 100644
--- a/crates/ra_ide_api/src/syntax_tree.rs
+++ b/crates/ra_ide_api/src/syntax_tree.rs
@@ -18,7 +18,7 @@ pub(crate) fn syntax_tree(
        let node = match algo::find_covering_element(parse.tree().syntax(), text_range) {
            SyntaxElement::Node(node) => node,
            SyntaxElement::Token(token) => {
-                if let Some(tree) = syntax_tree_for_string(token, text_range) {
+                if let Some(tree) = syntax_tree_for_string(&token, text_range) {
                    return tree;
                }
                token.parent()
@@ -33,7 +33,7 @@ pub(crate) fn syntax_tree(
 /// Attempts parsing the selected contents of a string literal
 /// as rust syntax and returns its syntax tree
-fn syntax_tree_for_string(token: SyntaxToken, text_range: TextRange) -> Option<String> {
+fn syntax_tree_for_string(token: &SyntaxToken, text_range: TextRange) -> Option<String> {
    // When the range is inside a string
    // we'll attempt parsing it as rust syntax
    // to provide the syntax tree of the contents of the string
@@ -43,7 +43,7 @@ fn syntax_tree_for_string(token: SyntaxToken, text_range: TextRange) -> Option<S
    }
 }
-fn syntax_tree_for_token(node: SyntaxToken, text_range: TextRange) -> Option<String> {
+fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<String> {
    // Range of the full node
    let node_range = node.range();
    let text = node.text().to_string();
diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs
index 01eb32b2f..ad0ababcc 100644
--- a/crates/ra_ide_api/src/typing.rs
+++ b/crates/ra_ide_api/src/typing.rs
@@ -1,15 +1,16 @@
-use crate::{db::RootDatabase, SourceChange, SourceFileEdit};
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
 use ra_syntax::{
    algo::{find_node_at_offset, find_token_at_offset, TokenAtOffset},
    ast::{self, AstToken},
-    AstNode, SourceFile,
+    AstNode, SmolStr, SourceFile,
    SyntaxKind::*,
    SyntaxToken, TextRange, TextUnit,
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
+use crate::{db::RootDatabase, SourceChange, SourceFileEdit};
 pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<SourceChange> {
    let parse = db.parse(position.file_id);
    let file = parse.tree();
@@ -43,15 +44,15 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Sour
    )
 }
-fn node_indent<'a>(file: &'a SourceFile, token: SyntaxToken) -> Option<&'a str> {
+fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
    let ws = match find_token_at_offset(file.syntax(), token.range().start()) {
        TokenAtOffset::Between(l, r) => {
-            assert!(r == token);
+            assert!(r == *token);
            l
        }
        TokenAtOffset::Single(n) => {
-            assert!(n == token);
+            assert!(n == *token);
-            return Some("");
+            return Some("".into());
        }
        TokenAtOffset::None => unreachable!(),
    };
@@ -60,12 +61,12 @@ fn node_indent<'a>(file: &'a SourceFile, token: SyntaxToken) -> Option<&'a str>
    }
    let text = ws.text();
    let pos = text.rfind('\n').map(|it| it + 1).unwrap_or(0);
-    Some(&text[pos..])
+    Some(text[pos..].into())
 }
 pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option<TextEdit> {
    assert_eq!(file.syntax().text().char_at(eq_offset), Some('='));
-    let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?;
+    let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?;
    if let_stmt.has_semi() {
        return None;
    }
@@ -141,7 +142,7 @@ mod tests {
            edit.insert(offset, "=".to_string());
            let before = edit.finish().apply(&before);
            let parse = SourceFile::parse(&before);
-            if let Some(result) = on_eq_typed(parse.tree(), offset) {
+            if let Some(result) = on_eq_typed(&parse.tree(), offset) {
                let actual = result.apply(&before);
                assert_eq_text!(after, &actual);
            } else {
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index c7c06c7fd..f185aecb7 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -599,7 +599,8 @@ mod tests {
        let macro_definition =
            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-        let (definition_tt, _) = ast_to_token_tree(macro_definition.token_tree().unwrap()).unwrap();
+        let (definition_tt, _) =
+            ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
        crate::MacroRules::parse(&definition_tt).unwrap()
    }
@@ -611,7 +612,8 @@ mod tests {
        let macro_invocation =
            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-        let (invocation_tt, _) = ast_to_token_tree(macro_invocation.token_tree().unwrap()).unwrap();
+        let (invocation_tt, _) =
+            ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
        expand_rule(&rules.rules[0], &invocation_tt)
    }
diff --git a/crates/ra_mbe/src/mbe_parser.rs b/crates/ra_mbe/src/mbe_parser.rs
index cddb4a7b4..954b84d9d 100644
--- a/crates/ra_mbe/src/mbe_parser.rs
+++ b/crates/ra_mbe/src/mbe_parser.rs
@@ -179,7 +179,8 @@ mod tests {
        let macro_definition =
            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-        let (definition_tt, _) = ast_to_token_tree(macro_definition.token_tree().unwrap()).unwrap();
+        let (definition_tt, _) =
+            ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
        parse(&definition_tt)
    }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index bfc351f81..64ed6a517 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -2,7 +2,7 @@ use crate::subtree_source::SubtreeTokenSource;
 use crate::ExpandError;
 use ra_parser::{ParseError, TreeSink};
 use ra_syntax::{
-    ast, AstNode, Parse, SmolStr, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxNode,
+    ast, AstNode, AstToken, Parse, SmolStr, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxNode,
    SyntaxTreeBuilder, TextRange, TextUnit, T,
 };
 use tt::buffer::{Cursor, TokenBuffer};
@@ -116,8 +116,6 @@ impl TokenMap {
 /// and strips the ending `*/`
 /// And then quote the string, which is needed to convert to `tt::Literal`
 fn doc_comment_text(comment: &ast::Comment) -> SmolStr {
-    use ast::AstToken;
    let prefix_len = comment.prefix().len();
    let mut text = &comment.text()[prefix_len..];
@@ -132,9 +130,8 @@ fn doc_comment_text(comment: &ast::Comment) -> SmolStr {
    text.into()
 }
-fn convert_doc_comment<'a>(token: &ra_syntax::SyntaxToken<'a>) -> Option<Vec<tt::TokenTree>> {
+fn convert_doc_comment(token: &ra_syntax::SyntaxToken) -> Option<Vec<tt::TokenTree>> {
-    use ast::AstToken;
+    let comment = ast::Comment::cast(token.clone())?;
-    let comment = ast::Comment::cast(*token)?;
    let doc = comment.kind().doc?;
    // Make `doc="\" Comments\""
@@ -245,7 +242,7 @@ fn convert_tt(
                }
            }
            SyntaxElement::Node(node) => {
-                let child = convert_tt(token_map, global_offset, node)?.into();
+                let child = convert_tt(token_map, global_offset, &node)?.into();
                token_trees.push(child);
            }
        };
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 419b2c099..38a31109d 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -37,8 +37,8 @@ impl_froms!(TokenTree: Leaf, Subtree);
    let macro_invocation =
        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    let (definition_tt, _) = ast_to_token_tree(macro_definition.token_tree().unwrap()).unwrap();
+    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
-    let (invocation_tt, _) = ast_to_token_tree(macro_invocation.token_tree().unwrap()).unwrap();
+    let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
    let rules = crate::MacroRules::parse(&definition_tt).unwrap();
    let expansion = rules.expand(&invocation_tt).unwrap();
    assert_eq!(
@@ -53,7 +53,7 @@ pub(crate) fn create_rules(macro_definition: &str) -> MacroRules {
    let macro_definition =
        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    let (definition_tt, _) = ast_to_token_tree(macro_definition.token_tree().unwrap()).unwrap();
+    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
    crate::MacroRules::parse(&definition_tt).unwrap()
 }
@@ -62,34 +62,25 @@ pub(crate) fn expand(rules: &MacroRules, invocation: &str) -> tt::Subtree {
    let macro_invocation =
        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    let (invocation_tt, _) = ast_to_token_tree(macro_invocation.token_tree().unwrap()).unwrap();
+    let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
    rules.expand(&invocation_tt).unwrap()
 }
-pub(crate) fn expand_to_items(
+pub(crate) fn expand_to_items(rules: &MacroRules, invocation: &str) -> ast::MacroItems {
-    rules: &MacroRules,
-    invocation: &str,
-) -> ra_syntax::TreeArc<ast::MacroItems> {
    let expanded = expand(rules, invocation);
-    token_tree_to_macro_items(&expanded).unwrap().tree().to_owned()
+    token_tree_to_macro_items(&expanded).unwrap().tree()
 }
 #[allow(unused)]
-pub(crate) fn expand_to_stmts(
+pub(crate) fn expand_to_stmts(rules: &MacroRules, invocation: &str) -> ast::MacroStmts {
-    rules: &MacroRules,
-    invocation: &str,
-) -> ra_syntax::TreeArc<ast::MacroStmts> {
    let expanded = expand(rules, invocation);
-    token_tree_to_macro_stmts(&expanded).unwrap().tree().to_owned()
+    token_tree_to_macro_stmts(&expanded).unwrap().tree()
 }
-pub(crate) fn expand_to_expr(
+pub(crate) fn expand_to_expr(rules: &MacroRules, invocation: &str) -> ast::Expr {
-    rules: &MacroRules,
-    invocation: &str,
-) -> ra_syntax::TreeArc<ast::Expr> {
    let expanded = expand(rules, invocation);
-    token_tree_to_expr(&expanded).unwrap().tree().to_owned()
+    token_tree_to_expr(&expanded).unwrap().tree()
 }
 pub(crate) fn text_to_tokentree(text: &str) -> tt::Subtree {
@@ -97,7 +88,7 @@ pub(crate) fn text_to_tokentree(text: &str) -> tt::Subtree {
    let wrapped = format!("wrap_macro!( {} )", text);
    let wrapped = ast::SourceFile::parse(&wrapped);
    let wrapped = wrapped.tree().syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-    let mut wrapped = ast_to_token_tree(wrapped).unwrap().0;
+    let mut wrapped = ast_to_token_tree(&wrapped).unwrap().0;
    wrapped.delimiter = tt::Delimiter::None;
    wrapped
@@ -164,8 +155,8 @@ pub(crate) fn assert_expansion(
    let (expanded_tree, expected_tree) = match kind {
        MacroKind::Items => {
-            let expanded_tree = token_tree_to_macro_items(&expanded).unwrap().tree().to_owned();
+            let expanded_tree = token_tree_to_macro_items(&expanded).unwrap().tree();
-            let expected_tree = token_tree_to_macro_items(&expected).unwrap().tree().to_owned();
+            let expected_tree = token_tree_to_macro_items(&expected).unwrap().tree();
            (
                debug_dump_ignore_spaces(expanded_tree.syntax()).trim().to_string(),
@@ -174,8 +165,8 @@ pub(crate) fn assert_expansion(
        }
        MacroKind::Stmts => {
-            let expanded_tree = token_tree_to_macro_stmts(&expanded).unwrap().tree().to_owned();
+            let expanded_tree = token_tree_to_macro_stmts(&expanded).unwrap().tree();
-            let expected_tree = token_tree_to_macro_stmts(&expected).unwrap().tree().to_owned();
+            let expected_tree = token_tree_to_macro_stmts(&expected).unwrap().tree();
            (
                debug_dump_ignore_spaces(expanded_tree.syntax()).trim().to_string(),
@@ -419,7 +410,7 @@ fn test_expand_to_item_list() {
            ",
    );
    let expansion = expand(&rules, "structs!(Foo, Bar);");
-    let tree = token_tree_to_macro_items(&expansion).unwrap().tree().to_owned();
+    let tree = token_tree_to_macro_items(&expansion).unwrap().tree();
    assert_eq!(
        tree.syntax().debug_dump().trim(),
        r#"
@@ -537,7 +528,7 @@ fn test_tt_to_stmts() {
    );
    let expanded = expand(&rules, "foo!{}");
-    let stmts = token_tree_to_macro_stmts(&expanded).unwrap().tree().to_owned();
+    let stmts = token_tree_to_macro_stmts(&expanded).unwrap().tree();
    assert_eq!(
        stmts.syntax().debug_dump().trim(),
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 37a91ea35..a5565de33 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -10,7 +10,7 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 [dependencies]
 unicode-xid = "0.1.0"
 itertools = "0.8.0"
-rowan = "0.5.0"
+rowan = "0.5.6"
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index fad8da132..e2de5e0e3 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -9,8 +9,8 @@ pub use rowan::TokenAtOffset;
 pub fn find_token_at_offset(node: &SyntaxNode, offset: TextUnit) -> TokenAtOffset<SyntaxToken> {
    match node.0.token_at_offset(offset) {
        TokenAtOffset::None => TokenAtOffset::None,
-        TokenAtOffset::Single(n) => TokenAtOffset::Single(n.into()),
+        TokenAtOffset::Single(n) => TokenAtOffset::Single(SyntaxToken(n)),
-        TokenAtOffset::Between(l, r) => TokenAtOffset::Between(l.into(), r.into()),
+        TokenAtOffset::Between(l, r) => TokenAtOffset::Between(SyntaxToken(l), SyntaxToken(r)),
    }
 }
@@ -22,7 +22,7 @@ pub fn find_token_at_offset(node: &SyntaxNode, offset: TextUnit) -> TokenAtOffse
 pub fn ancestors_at_offset(
    node: &SyntaxNode,
    offset: TextUnit,
-) -> impl Iterator<Item = &SyntaxNode> {
+) -> impl Iterator<Item = SyntaxNode> {
    find_token_at_offset(node, offset)
        .map(|token| token.parent().ancestors())
        .kmerge_by(|node1, node2| node1.range().len() < node2.range().len())
@@ -37,7 +37,7 @@ pub fn ancestors_at_offset(
 /// ```
 ///
 /// then the shorter node will be silently preferred.
-pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) -> Option<&N> {
+pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) -> Option<N> {
    ancestors_at_offset(syntax, offset).find_map(N::cast)
 }
@@ -59,5 +59,5 @@ pub fn non_trivia_sibling(element: SyntaxElement, direction: Direction) -> Optio
 }
 pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxElement {
-    root.0.covering_node(range).into()
+    SyntaxElement::new(root.0.covering_node(range))
 }
diff --git a/crates/ra_syntax/src/algo/visit.rs b/crates/ra_syntax/src/algo/visit.rs
index 81a99228f..87bd15cc0 100644
--- a/crates/ra_syntax/src/algo/visit.rs
+++ b/crates/ra_syntax/src/algo/visit.rs
@@ -16,7 +16,7 @@ pub trait Visitor<'a>: Sized {
    fn visit<N, F>(self, f: F) -> Vis<Self, N, F>
    where
        N: AstNode + 'a,
-        F: FnOnce(&'a N) -> Self::Output,
+        F: FnOnce(N) -> Self::Output,
    {
        Vis { inner: self, f, ph: PhantomData }
    }
@@ -29,7 +29,7 @@ pub trait VisitorCtx<'a>: Sized {
    fn visit<N, F>(self, f: F) -> VisCtx<Self, N, F>
    where
        N: AstNode + 'a,
-        F: FnOnce(&'a N, Self::Ctx) -> Self::Output,
+        F: FnOnce(N, Self::Ctx) -> Self::Output,
    {
        VisCtx { inner: self, f, ph: PhantomData }
    }
@@ -74,13 +74,13 @@ impl<'a, V, N, F> Visitor<'a> for Vis<V, N, F>
 where
    V: Visitor<'a>,
    N: AstNode + 'a,
-    F: FnOnce(&'a N) -> <V as Visitor<'a>>::Output,
+    F: FnOnce(N) -> <V as Visitor<'a>>::Output,
 {
    type Output = <V as Visitor<'a>>::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))
+        inner.accept(node).or_else(|| N::cast(node.clone()).map(f))
    }
 }
@@ -95,14 +95,14 @@ impl<'a, V, N, F> VisitorCtx<'a> for VisCtx<V, N, F>
 where
    V: VisitorCtx<'a>,
    N: AstNode + 'a,
-    F: FnOnce(&'a N, <V as VisitorCtx<'a>>::Ctx) -> <V as VisitorCtx<'a>>::Output,
+    F: FnOnce(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: &'a SyntaxNode) -> Result<Self::Output, Self::Ctx> {
        let VisCtx { inner, f, .. } = self;
-        inner.accept(node).or_else(|ctx| match N::cast(node) {
+        inner.accept(node).or_else(|ctx| match N::cast(node.clone()) {
            None => Err(ctx),
            Some(node) => Ok(f(node, ctx)),
        })
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 3dcf39f7e..ceb603c50 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -9,7 +9,7 @@ mod expr_extensions;
 use std::marker::PhantomData;
 use crate::{
-    syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken, TreeArc},
+    syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken},
    SmolStr,
 };
@@ -25,51 +25,49 @@ pub use self::{
 /// 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:
+pub trait AstNode: Clone {
-    rowan::TransparentNewType<Repr = rowan::SyntaxNode> + ToOwned<Owned = TreeArc<Self>>
+    fn cast(syntax: SyntaxNode) -> Option<Self>
-{
-    fn cast(syntax: &SyntaxNode) -> Option<&Self>
    where
        Self: Sized;
    fn syntax(&self) -> &SyntaxNode;
 }
 /// Like `AstNode`, but wraps tokens rather than interior nodes.
-pub trait AstToken<'a> {
+pub trait AstToken {
-    fn cast(token: SyntaxToken<'a>) -> Option<Self>
+    fn cast(token: SyntaxToken) -> Option<Self>
    where
        Self: Sized;
-    fn syntax(&self) -> SyntaxToken<'a>;
+    fn syntax(&self) -> &SyntaxToken;
-    fn text(&self) -> &'a SmolStr {
+    fn text(&self) -> &SmolStr {
        self.syntax().text()
    }
 }
 /// An iterator over `SyntaxNode` children of a particular AST type.
 #[derive(Debug)]
-pub struct AstChildren<'a, N> {
+pub struct AstChildren<N> {
-    inner: SyntaxNodeChildren<'a>,
+    inner: SyntaxNodeChildren,
    ph: PhantomData<N>,
 }
-impl<'a, N> AstChildren<'a, N> {
+impl<N> AstChildren<N> {
-    fn new(parent: &'a SyntaxNode) -> Self {
+    fn new(parent: &SyntaxNode) -> Self {
        AstChildren { inner: parent.children(), ph: PhantomData }
    }
 }
-impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
+impl<N: AstNode> Iterator for AstChildren<N> {
-    type Item = &'a N;
+    type Item = N;
-    fn next(&mut self) -> Option<&'a N> {
+    fn next(&mut self) -> Option<N> {
        self.inner.by_ref().find_map(N::cast)
    }
 }
-fn child_opt<P: AstNode, C: AstNode>(parent: &P) -> Option<&C> {
+fn child_opt<P: AstNode + ?Sized, C: AstNode>(parent: &P) -> Option<C> {
    children(parent).next()
 }
-fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
+fn children<P: AstNode + ?Sized, C: AstNode>(parent: &P) -> AstChildren<C> {
    AstChildren::new(parent.syntax())
 }
@@ -123,7 +121,7 @@ fn test_doc_comment_preserves_indents() {
 #[test]
 fn test_where_predicates() {
-    fn assert_bound(text: &str, bound: Option<&TypeBound>) {
+    fn assert_bound(text: &str, bound: Option<TypeBound>) {
        assert_eq!(text, bound.unwrap().syntax().text().to_string());
    }
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 4355e3587..ca1773908 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -8,20 +8,20 @@ use crate::{
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ElseBranch<'a> {
+pub enum ElseBranch {
-    Block(&'a ast::Block),
+    Block(ast::Block),
-    IfExpr(&'a ast::IfExpr),
+    IfExpr(ast::IfExpr),
 }
 impl ast::IfExpr {
-    pub fn then_branch(&self) -> Option<&ast::Block> {
+    pub fn then_branch(&self) -> Option<ast::Block> {
        self.blocks().nth(0)
    }
    pub fn else_branch(&self) -> Option<ElseBranch> {
        let res = match self.blocks().nth(1) {
            Some(block) => ElseBranch::Block(block),
            None => {
-                let elif: &ast::IfExpr = child_opt(self)?;
+                let elif: ast::IfExpr = child_opt(self)?;
                ElseBranch::IfExpr(elif)
            }
        };
@@ -60,7 +60,7 @@ impl ast::PrefixExpr {
    }
    pub fn op_token(&self) -> Option<SyntaxToken> {
-        self.syntax().first_child_or_token()?.as_token()
+        self.syntax().first_child_or_token()?.as_token().cloned()
    }
 }
@@ -132,7 +132,7 @@ pub enum BinOp {
 impl ast::BinExpr {
    fn op_details(&self) -> Option<(SyntaxToken, BinOp)> {
-        self.syntax().children_with_tokens().filter_map(|it| it.as_token()).find_map(|c| {
+        self.syntax().children_with_tokens().filter_map(|it| it.as_token().cloned()).find_map(|c| {
            match c.kind() {
                T![||] => Some((c, BinOp::BooleanOr)),
                T![&&] => Some((c, BinOp::BooleanAnd)),
@@ -178,15 +178,15 @@ impl ast::BinExpr {
        self.op_details().map(|t| t.0)
    }
-    pub fn lhs(&self) -> Option<&ast::Expr> {
+    pub fn lhs(&self) -> Option<ast::Expr> {
        children(self).nth(0)
    }
-    pub fn rhs(&self) -> Option<&ast::Expr> {
+    pub fn rhs(&self) -> Option<ast::Expr> {
        children(self).nth(1)
    }
-    pub fn sub_exprs(&self) -> (Option<&ast::Expr>, Option<&ast::Expr>) {
+    pub fn sub_exprs(&self) -> (Option<ast::Expr>, Option<ast::Expr>) {
        let mut children = children(self);
        let first = children.next();
        let second = children.next();
@@ -194,9 +194,9 @@ impl ast::BinExpr {
    }
 }
-pub enum ArrayExprKind<'a> {
+pub enum ArrayExprKind {
-    Repeat { initializer: Option<&'a ast::Expr>, repeat: Option<&'a ast::Expr> },
+    Repeat { initializer: Option<ast::Expr>, repeat: Option<ast::Expr> },
-    ElementList(AstChildren<'a, ast::Expr>),
+    ElementList(AstChildren<ast::Expr>),
 }
 impl ast::ArrayExpr {
@@ -275,12 +275,12 @@ impl ast::Literal {
 #[test]
 fn test_literal_with_attr() {
    let parse = ast::SourceFile::parse(r#"const _: &str = { #[attr] "Hello" };"#);
-    let lit = parse.tree.syntax().descendants().find_map(ast::Literal::cast).unwrap();
+    let lit = parse.tree().syntax().descendants().find_map(ast::Literal::cast).unwrap();
    assert_eq!(lit.token().text(), r#""Hello""#);
 }
 impl ast::NamedField {
-    pub fn parent_struct_lit(&self) -> &ast::StructLit {
+    pub fn parent_struct_lit(&self) -> ast::StructLit {
        self.syntax().ancestors().find_map(ast::StructLit::cast).unwrap()
    }
 }
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 72a30232d..5420f67ff 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -4,7 +4,7 @@
 use itertools::Itertools;
 use crate::{
-    ast::{self, child_opt, children, AstNode},
+    ast::{self, child_opt, children, AstNode, SyntaxNode},
    SmolStr, SyntaxElement,
    SyntaxKind::*,
    SyntaxToken, T,
@@ -13,15 +13,20 @@ use ra_parser::SyntaxKind;
 impl ast::Name {
    pub fn text(&self) -> &SmolStr {
-        let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
+        text_of_first_token(self.syntax())
-        ident.text()
    }
 }
 impl ast::NameRef {
    pub fn text(&self) -> &SmolStr {
-        let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
+        text_of_first_token(self.syntax())
-        ident.text()
+    }
+}
+fn text_of_first_token(node: &SyntaxNode) -> &SmolStr {
+    match node.0.green().children().first() {
+        Some(rowan::GreenElement::Token(it)) => it.text(),
+        _ => panic!(),
    }
 }
@@ -50,10 +55,10 @@ impl ast::Attr {
        }
    }
-    pub fn as_call(&self) -> Option<(SmolStr, &ast::TokenTree)> {
+    pub fn as_call(&self) -> Option<(SmolStr, ast::TokenTree)> {
        let tt = self.value()?;
        let (_bra, attr, args, _ket) = tt.syntax().children_with_tokens().collect_tuple()?;
-        let args = ast::TokenTree::cast(args.as_node()?)?;
+        let args = ast::TokenTree::cast(args.as_node()?.clone())?;
        if attr.kind() == IDENT {
            Some((attr.as_token()?.text().clone(), args))
        } else {
@@ -86,16 +91,16 @@ impl ast::Attr {
    }
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PathSegmentKind<'a> {
+pub enum PathSegmentKind {
-    Name(&'a ast::NameRef),
+    Name(ast::NameRef),
    SelfKw,
    SuperKw,
    CrateKw,
 }
 impl ast::PathSegment {
-    pub fn parent_path(&self) -> &ast::Path {
+    pub fn parent_path(&self) -> ast::Path {
        self.syntax()
            .parent()
            .and_then(ast::Path::cast)
@@ -125,7 +130,7 @@ impl ast::PathSegment {
 }
 impl ast::Path {
-    pub fn parent_path(&self) -> Option<&ast::Path> {
+    pub fn parent_path(&self) -> Option<ast::Path> {
        self.syntax().parent().and_then(ast::Path::cast)
    }
 }
@@ -146,7 +151,7 @@ impl ast::UseTree {
 }
 impl ast::UseTreeList {
-    pub fn parent_use_tree(&self) -> &ast::UseTree {
+    pub fn parent_use_tree(&self) -> ast::UseTree {
        self.syntax()
            .parent()
            .and_then(ast::UseTree::cast)
@@ -155,21 +160,21 @@ impl ast::UseTreeList {
 }
 impl ast::ImplBlock {
-    pub fn target_type(&self) -> Option<&ast::TypeRef> {
+    pub fn target_type(&self) -> Option<ast::TypeRef> {
        match self.target() {
            (Some(t), None) | (_, Some(t)) => Some(t),
            _ => None,
        }
    }
-    pub fn target_trait(&self) -> Option<&ast::TypeRef> {
+    pub fn target_trait(&self) -> Option<ast::TypeRef> {
        match self.target() {
            (Some(t), Some(_)) => Some(t),
            _ => None,
        }
    }
-    fn target(&self) -> (Option<&ast::TypeRef>, Option<&ast::TypeRef>) {
+    fn target(&self) -> (Option<ast::TypeRef>, Option<ast::TypeRef>) {
        let mut types = children(self);
        let first = types.next();
        let second = types.next();
@@ -182,13 +187,13 @@ impl ast::ImplBlock {
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum StructKind<'a> {
+pub enum StructKind {
-    Tuple(&'a ast::PosFieldDefList),
+    Tuple(ast::PosFieldDefList),
-    Named(&'a ast::NamedFieldDefList),
+    Named(ast::NamedFieldDefList),
    Unit,
 }
-impl StructKind<'_> {
+impl StructKind {
    fn from_node<N: AstNode>(node: &N) -> StructKind {
        if let Some(nfdl) = child_opt::<_, ast::NamedFieldDefList>(node) {
            StructKind::Named(nfdl)
@@ -218,7 +223,7 @@ impl ast::StructDef {
 }
 impl ast::EnumVariant {
-    pub fn parent_enum(&self) -> &ast::EnumDef {
+    pub fn parent_enum(&self) -> ast::EnumDef {
        self.syntax()
            .parent()
            .and_then(|it| it.parent())
@@ -231,10 +236,10 @@ impl ast::EnumVariant {
 }
 impl ast::FnDef {
-    pub fn semicolon_token(&self) -> Option<SyntaxToken<'_>> {
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
        self.syntax()
            .last_child_or_token()
-            .and_then(|it| it.as_token())
+            .and_then(|it| it.as_token().cloned())
            .filter(|it| it.kind() == T![;])
    }
 }
@@ -258,9 +263,9 @@ impl ast::ExprStmt {
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum FieldKind<'a> {
+pub enum FieldKind {
-    Name(&'a ast::NameRef),
+    Name(ast::NameRef),
-    Index(SyntaxToken<'a>),
+    Index(SyntaxToken),
 }
 impl ast::FieldExpr {
@@ -271,6 +276,7 @@ impl ast::FieldExpr {
            .find(|c| c.kind() == SyntaxKind::INT_NUMBER || c.kind() == SyntaxKind::FLOAT_NUMBER)
            .as_ref()
            .and_then(SyntaxElement::as_token)
+            .cloned()
    }
    pub fn field_access(&self) -> Option<FieldKind> {
@@ -326,7 +332,7 @@ impl ast::SelfParam {
    pub fn self_kw_token(&self) -> SyntaxToken {
        self.syntax()
            .children_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == T![self])
            .expect("invalid tree: self param must have self")
    }
@@ -355,7 +361,7 @@ impl ast::LifetimeParam {
    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
        self.syntax()
            .children_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == LIFETIME)
    }
 }
@@ -364,7 +370,7 @@ impl ast::WherePred {
    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
        self.syntax()
            .children_with_tokens()
-            .filter_map(|it| it.as_token())
+            .filter_map(|it| it.as_token().cloned())
            .find(|it| it.kind() == LIFETIME)
    }
 }
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 1d888e709..a1f320257 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -9,503 +9,365 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
-use rowan::TransparentNewType;
 use crate::{
    SyntaxNode, SyntaxKind::*,
-    syntax_node::{TreeArc},
    ast::{self, AstNode},
 };
 // Alias
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct Alias {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Alias {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for Alias {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ALIAS => Some(Alias::from_repr(syntax.into_repr())),
+            ALIAS => Some(Alias { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Alias {
-    type Owned = TreeArc<Alias>;
-    fn to_owned(&self) -> TreeArc<Alias> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::NameOwner for Alias {}
 impl Alias {}
 // ArgList
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ArgList {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ArgList {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ArgList {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ARG_LIST => Some(ArgList::from_repr(syntax.into_repr())),
+            ARG_LIST => Some(ArgList { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ArgList {
-    type Owned = TreeArc<ArgList>;
-    fn to_owned(&self) -> TreeArc<ArgList> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ArgList {
-    pub fn args(&self) -> impl Iterator<Item = &Expr> {
+    pub fn args(&self) -> impl Iterator<Item = Expr> {
        super::children(self)
    }
 }
 // ArrayExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ArrayExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ArrayExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ArrayExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ARRAY_EXPR => Some(ArrayExpr::from_repr(syntax.into_repr())),
+            ARRAY_EXPR => Some(ArrayExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ArrayExpr {
-    type Owned = TreeArc<ArrayExpr>;
-    fn to_owned(&self) -> TreeArc<ArrayExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ArrayExpr {
-    pub fn exprs(&self) -> impl Iterator<Item = &Expr> {
+    pub fn exprs(&self) -> impl Iterator<Item = Expr> {
        super::children(self)
    }
 }
 // ArrayType
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ArrayType {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ArrayType {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ArrayType {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ARRAY_TYPE => Some(ArrayType::from_repr(syntax.into_repr())),
+            ARRAY_TYPE => Some(ArrayType { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ArrayType {
-    type Owned = TreeArc<ArrayType>;
-    fn to_owned(&self) -> TreeArc<ArrayType> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ArrayType {
-    pub fn type_ref(&self) -> Option<&TypeRef> {
+    pub fn type_ref(&self) -> Option<TypeRef> {
        super::child_opt(self)
    }
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // AssocTypeArg
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct AssocTypeArg {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for AssocTypeArg {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for AssocTypeArg {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ASSOC_TYPE_ARG => Some(AssocTypeArg::from_repr(syntax.into_repr())),
+            ASSOC_TYPE_ARG => Some(AssocTypeArg { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for AssocTypeArg {
-    type Owned = TreeArc<AssocTypeArg>;
-    fn to_owned(&self) -> TreeArc<AssocTypeArg> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl AssocTypeArg {
-    pub fn name_ref(&self) -> Option<&NameRef> {
+    pub fn name_ref(&self) -> Option<NameRef> {
        super::child_opt(self)
    }
-    pub fn type_ref(&self) -> Option<&TypeRef> {
+    pub fn type_ref(&self) -> Option<TypeRef> {
        super::child_opt(self)
    }
 }
 // Attr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct Attr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Attr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for Attr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ATTR => Some(Attr::from_repr(syntax.into_repr())),
+            ATTR => Some(Attr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Attr {
-    type Owned = TreeArc<Attr>;
-    fn to_owned(&self) -> TreeArc<Attr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl Attr {
-    pub fn value(&self) -> Option<&TokenTree> {
+    pub fn value(&self) -> Option<TokenTree> {
        super::child_opt(self)
    }
 }
 // BinExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct BinExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for BinExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for BinExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            BIN_EXPR => Some(BinExpr::from_repr(syntax.into_repr())),
+            BIN_EXPR => Some(BinExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for BinExpr {
-    type Owned = TreeArc<BinExpr>;
-    fn to_owned(&self) -> TreeArc<BinExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl BinExpr {}
 // BindPat
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct BindPat {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for BindPat {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for BindPat {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            BIND_PAT => Some(BindPat::from_repr(syntax.into_repr())),
+            BIND_PAT => Some(BindPat { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for BindPat {
-    type Owned = TreeArc<BindPat>;
-    fn to_owned(&self) -> TreeArc<BindPat> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::NameOwner for BindPat {}
 impl BindPat {
-    pub fn pat(&self) -> Option<&Pat> {
+    pub fn pat(&self) -> Option<Pat> {
        super::child_opt(self)
    }
 }
 // Block
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct Block {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Block {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for Block {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            BLOCK => Some(Block::from_repr(syntax.into_repr())),
+            BLOCK => Some(Block { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Block {
-    type Owned = TreeArc<Block>;
-    fn to_owned(&self) -> TreeArc<Block> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::AttrsOwner for Block {}
 impl Block {
-    pub fn statements(&self) -> impl Iterator<Item = &Stmt> {
+    pub fn statements(&self) -> impl Iterator<Item = Stmt> {
        super::children(self)
    }
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // BlockExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct BlockExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for BlockExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for BlockExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            BLOCK_EXPR => Some(BlockExpr::from_repr(syntax.into_repr())),
+            BLOCK_EXPR => Some(BlockExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for BlockExpr {
-    type Owned = TreeArc<BlockExpr>;
-    fn to_owned(&self) -> TreeArc<BlockExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl BlockExpr {
-    pub fn block(&self) -> Option<&Block> {
+    pub fn block(&self) -> Option<Block> {
        super::child_opt(self)
    }
 }
 // BreakExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct BreakExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for BreakExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for BreakExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            BREAK_EXPR => Some(BreakExpr::from_repr(syntax.into_repr())),
+            BREAK_EXPR => Some(BreakExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for BreakExpr {
-    type Owned = TreeArc<BreakExpr>;
-    fn to_owned(&self) -> TreeArc<BreakExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl BreakExpr {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // CallExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct CallExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for CallExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for CallExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            CALL_EXPR => Some(CallExpr::from_repr(syntax.into_repr())),
+            CALL_EXPR => Some(CallExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for CallExpr {
-    type Owned = TreeArc<CallExpr>;
-    fn to_owned(&self) -> TreeArc<CallExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::ArgListOwner for CallExpr {}
 impl CallExpr {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // CastExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct CastExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for CastExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for CastExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            CAST_EXPR => Some(CastExpr::from_repr(syntax.into_repr())),
+            CAST_EXPR => Some(CastExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for CastExpr {
-    type Owned = TreeArc<CastExpr>;
-    fn to_owned(&self) -> TreeArc<CastExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl CastExpr {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
-    pub fn type_ref(&self) -> Option<&TypeRef> {
+    pub fn type_ref(&self) -> Option<TypeRef> {
        super::child_opt(self)
    }
 }
 // Condition
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct Condition {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Condition {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for Condition {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            CONDITION => Some(Condition::from_repr(syntax.into_repr())),
+            CONDITION => Some(Condition { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Condition {
-    type Owned = TreeArc<Condition>;
-    fn to_owned(&self) -> TreeArc<Condition> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl Condition {
-    pub fn pat(&self) -> Option<&Pat> {
+    pub fn pat(&self) -> Option<Pat> {
        super::child_opt(self)
    }
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // ConstDef
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ConstDef {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ConstDef {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ConstDef {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            CONST_DEF => Some(ConstDef::from_repr(syntax.into_repr())),
+            CONST_DEF => Some(ConstDef { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ConstDef {
-    type Owned = TreeArc<ConstDef>;
-    fn to_owned(&self) -> TreeArc<ConstDef> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::VisibilityOwner for ConstDef {}
 impl ast::NameOwner for ConstDef {}
@@ -514,93 +376,66 @@ impl ast::AttrsOwner for ConstDef {}
 impl ast::DocCommentsOwner for ConstDef {}
 impl ast::TypeAscriptionOwner for ConstDef {}
 impl ConstDef {
-    pub fn body(&self) -> Option<&Expr> {
+    pub fn body(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // ContinueExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ContinueExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ContinueExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ContinueExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            CONTINUE_EXPR => Some(ContinueExpr::from_repr(syntax.into_repr())),
+            CONTINUE_EXPR => Some(ContinueExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ContinueExpr {
-    type Owned = TreeArc<ContinueExpr>;
-    fn to_owned(&self) -> TreeArc<ContinueExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ContinueExpr {}
 // DynTraitType
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct DynTraitType {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for DynTraitType {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for DynTraitType {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            DYN_TRAIT_TYPE => Some(DynTraitType::from_repr(syntax.into_repr())),
+            DYN_TRAIT_TYPE => Some(DynTraitType { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for DynTraitType {
-    type Owned = TreeArc<DynTraitType>;
-    fn to_owned(&self) -> TreeArc<DynTraitType> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {}
 // EnumDef
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct EnumDef {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for EnumDef {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for EnumDef {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ENUM_DEF => Some(EnumDef::from_repr(syntax.into_repr())),
+            ENUM_DEF => Some(EnumDef { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for EnumDef {
-    type Owned = TreeArc<EnumDef>;
-    fn to_owned(&self) -> TreeArc<EnumDef> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::VisibilityOwner for EnumDef {}
 impl ast::NameOwner for EnumDef {}
@@ -608,269 +443,247 @@ impl ast::TypeParamsOwner for EnumDef {}
 impl ast::AttrsOwner for EnumDef {}
 impl ast::DocCommentsOwner for EnumDef {}
 impl EnumDef {
-    pub fn variant_list(&self) -> Option<&EnumVariantList> {
+    pub fn variant_list(&self) -> Option<EnumVariantList> {
        super::child_opt(self)
    }
 }
 // EnumVariant
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct EnumVariant {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for EnumVariant {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for EnumVariant {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ENUM_VARIANT => Some(EnumVariant::from_repr(syntax.into_repr())),
+            ENUM_VARIANT => Some(EnumVariant { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for EnumVariant {
-    type Owned = TreeArc<EnumVariant>;
-    fn to_owned(&self) -> TreeArc<EnumVariant> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::NameOwner for EnumVariant {}
 impl ast::DocCommentsOwner for EnumVariant {}
 impl ast::AttrsOwner for EnumVariant {}
 impl EnumVariant {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // EnumVariantList
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct EnumVariantList {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for EnumVariantList {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for EnumVariantList {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            ENUM_VARIANT_LIST => Some(EnumVariantList::from_repr(syntax.into_repr())),
+            ENUM_VARIANT_LIST => Some(EnumVariantList { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for EnumVariantList {
-    type Owned = TreeArc<EnumVariantList>;
-    fn to_owned(&self) -> TreeArc<EnumVariantList> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl EnumVariantList {
-    pub fn variants(&self) -> impl Iterator<Item = &EnumVariant> {
+    pub fn variants(&self) -> impl Iterator<Item = EnumVariant> {
        super::children(self)
    }
 }
 // Expr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct Expr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Expr {
-    type Repr = rowan::SyntaxNode;
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ExprKind<'a> {
+pub enum ExprKind {
-    TupleExpr(&'a TupleExpr),
+    TupleExpr(TupleExpr),
-    ArrayExpr(&'a ArrayExpr),
+    ArrayExpr(ArrayExpr),
-    ParenExpr(&'a ParenExpr),
+    ParenExpr(ParenExpr),
-    PathExpr(&'a PathExpr),
+    PathExpr(PathExpr),
-    LambdaExpr(&'a LambdaExpr),
+    LambdaExpr(LambdaExpr),
-    IfExpr(&'a IfExpr),
+    IfExpr(IfExpr),
-    LoopExpr(&'a LoopExpr),
+    LoopExpr(LoopExpr),
-    ForExpr(&'a ForExpr),
+    ForExpr(ForExpr),
-    WhileExpr(&'a WhileExpr),
+    WhileExpr(WhileExpr),
-    ContinueExpr(&'a ContinueExpr),
+    ContinueExpr(ContinueExpr),
-    BreakExpr(&'a BreakExpr),
+    BreakExpr(BreakExpr),
-    Label(&'a Label),
+    Label(Label),
-    BlockExpr(&'a BlockExpr),
+    BlockExpr(BlockExpr),
-    ReturnExpr(&'a ReturnExpr),
+    ReturnExpr(ReturnExpr),
-    MatchExpr(&'a MatchExpr),
+    MatchExpr(MatchExpr),
-    StructLit(&'a StructLit),
+    StructLit(StructLit),
-    CallExpr(&'a CallExpr),
+    CallExpr(CallExpr),
-    IndexExpr(&'a IndexExpr),
+    IndexExpr(IndexExpr),
-    MethodCallExpr(&'a MethodCallExpr),
+    MethodCallExpr(MethodCallExpr),
-    FieldExpr(&'a FieldExpr),
+    FieldExpr(FieldExpr),
-    TryExpr(&'a TryExpr),
+    TryExpr(TryExpr),
-    TryBlockExpr(&'a TryBlockExpr),
+    TryBlockExpr(TryBlockExpr),
-    CastExpr(&'a CastExpr),
+    CastExpr(CastExpr),
-    RefExpr(&'a RefExpr),
+    RefExpr(RefExpr),
-    PrefixExpr(&'a PrefixExpr),
+    PrefixExpr(PrefixExpr),
-    RangeExpr(&'a RangeExpr),
+    RangeExpr(RangeExpr),
-    BinExpr(&'a BinExpr),
+    BinExpr(BinExpr),
-    Literal(&'a Literal),
+    Literal(Literal),
-    MacroCall(&'a MacroCall),
+    MacroCall(MacroCall),
 }
-impl<'a> From<&'a TupleExpr> for &'a Expr {
+impl From<TupleExpr> for Expr {
-    fn from(n: &'a TupleExpr) -> &'a Expr {
+    fn from(n: TupleExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a ArrayExpr> for &'a Expr {
+impl From<ArrayExpr> for Expr {
-    fn from(n: &'a ArrayExpr) -> &'a Expr {
+    fn from(n: ArrayExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a ParenExpr> for &'a Expr {
+impl From<ParenExpr> for Expr {
-    fn from(n: &'a ParenExpr) -> &'a Expr {
+    fn from(n: ParenExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a PathExpr> for &'a Expr {
+impl From<PathExpr> for Expr {
-    fn from(n: &'a PathExpr) -> &'a Expr {
+    fn from(n: PathExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a LambdaExpr> for &'a Expr {
+impl From<LambdaExpr> for Expr {
-    fn from(n: &'a LambdaExpr) -> &'a Expr {
+    fn from(n: LambdaExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a IfExpr> for &'a Expr {
+impl From<IfExpr> for Expr {
-    fn from(n: &'a IfExpr) -> &'a Expr {
+    fn from(n: IfExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a LoopExpr> for &'a Expr {
+impl From<LoopExpr> for Expr {
-    fn from(n: &'a LoopExpr) -> &'a Expr {
+    fn from(n: LoopExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a ForExpr> for &'a Expr {
+impl From<ForExpr> for Expr {
-    fn from(n: &'a ForExpr) -> &'a Expr {
+    fn from(n: ForExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a WhileExpr> for &'a Expr {
+impl From<WhileExpr> for Expr {
-    fn from(n: &'a WhileExpr) -> &'a Expr {
+    fn from(n: WhileExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a ContinueExpr> for &'a Expr {
+impl From<ContinueExpr> for Expr {
-    fn from(n: &'a ContinueExpr) -> &'a Expr {
+    fn from(n: ContinueExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a BreakExpr> for &'a Expr {
+impl From<BreakExpr> for Expr {
-    fn from(n: &'a BreakExpr) -> &'a Expr {
+    fn from(n: BreakExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a Label> for &'a Expr {
+impl From<Label> for Expr {
-    fn from(n: &'a Label) -> &'a Expr {
+    fn from(n: Label) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a BlockExpr> for &'a Expr {
+impl From<BlockExpr> for Expr {
-    fn from(n: &'a BlockExpr) -> &'a Expr {
+    fn from(n: BlockExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a ReturnExpr> for &'a Expr {
+impl From<ReturnExpr> for Expr {
-    fn from(n: &'a ReturnExpr) -> &'a Expr {
+    fn from(n: ReturnExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a MatchExpr> for &'a Expr {
+impl From<MatchExpr> for Expr {
-    fn from(n: &'a MatchExpr) -> &'a Expr {
+    fn from(n: MatchExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a StructLit> for &'a Expr {
+impl From<StructLit> for Expr {
-    fn from(n: &'a StructLit) -> &'a Expr {
+    fn from(n: StructLit) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a CallExpr> for &'a Expr {
+impl From<CallExpr> for Expr {
-    fn from(n: &'a CallExpr) -> &'a Expr {
+    fn from(n: CallExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a IndexExpr> for &'a Expr {
+impl From<IndexExpr> for Expr {
-    fn from(n: &'a IndexExpr) -> &'a Expr {
+    fn from(n: IndexExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a MethodCallExpr> for &'a Expr {
+impl From<MethodCallExpr> for Expr {
-    fn from(n: &'a MethodCallExpr) -> &'a Expr {
+    fn from(n: MethodCallExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a FieldExpr> for &'a Expr {
+impl From<FieldExpr> for Expr {
-    fn from(n: &'a FieldExpr) -> &'a Expr {
+    fn from(n: FieldExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a TryExpr> for &'a Expr {
+impl From<TryExpr> for Expr {
-    fn from(n: &'a TryExpr) -> &'a Expr {
+    fn from(n: TryExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a TryBlockExpr> for &'a Expr {
+impl From<TryBlockExpr> for Expr {
-    fn from(n: &'a TryBlockExpr) -> &'a Expr {
+    fn from(n: TryBlockExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a CastExpr> for &'a Expr {
+impl From<CastExpr> for Expr {
-    fn from(n: &'a CastExpr) -> &'a Expr {
+    fn from(n: CastExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a RefExpr> for &'a Expr {
+impl From<RefExpr> for Expr {
-    fn from(n: &'a RefExpr) -> &'a Expr {
+    fn from(n: RefExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a PrefixExpr> for &'a Expr {
+impl From<PrefixExpr> for Expr {
-    fn from(n: &'a PrefixExpr) -> &'a Expr {
+    fn from(n: PrefixExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a RangeExpr> for &'a Expr {
+impl From<RangeExpr> for Expr {
-    fn from(n: &'a RangeExpr) -> &'a Expr {
+    fn from(n: RangeExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a BinExpr> for &'a Expr {
+impl From<BinExpr> for Expr {
-    fn from(n: &'a BinExpr) -> &'a Expr {
+    fn from(n: BinExpr) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a Literal> for &'a Expr {
+impl From<Literal> for Expr {
-    fn from(n: &'a Literal) -> &'a Expr {
+    fn from(n: Literal) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
-impl<'a> From<&'a MacroCall> for &'a Expr {
+impl From<MacroCall> for Expr {
-    fn from(n: &'a MacroCall) -> &'a Expr {
+    fn from(n: MacroCall) -> Expr {
-        Expr::cast(&n.syntax).unwrap()
+        Expr::cast(n.syntax).unwrap()
    }
 }
 impl AstNode for Expr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
            | TUPLE_EXPR
            | ARRAY_EXPR
@@ -900,50 +713,45 @@ impl AstNode for Expr {
            | RANGE_EXPR
            | BIN_EXPR
            | LITERAL
-            | MACRO_CALL => Some(Expr::from_repr(syntax.into_repr())),
+            | MACRO_CALL => Some(Expr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Expr {
-    type Owned = TreeArc<Expr>;
-    fn to_owned(&self) -> TreeArc<Expr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl Expr {
    pub fn kind(&self) -> ExprKind {
        match self.syntax.kind() {
-            TUPLE_EXPR => ExprKind::TupleExpr(TupleExpr::cast(&self.syntax).unwrap()),
+            TUPLE_EXPR => ExprKind::TupleExpr(TupleExpr::cast(self.syntax.clone()).unwrap()),
-            ARRAY_EXPR => ExprKind::ArrayExpr(ArrayExpr::cast(&self.syntax).unwrap()),
+            ARRAY_EXPR => ExprKind::ArrayExpr(ArrayExpr::cast(self.syntax.clone()).unwrap()),
-            PAREN_EXPR => ExprKind::ParenExpr(ParenExpr::cast(&self.syntax).unwrap()),
+            PAREN_EXPR => ExprKind::ParenExpr(ParenExpr::cast(self.syntax.clone()).unwrap()),
-            PATH_EXPR => ExprKind::PathExpr(PathExpr::cast(&self.syntax).unwrap()),
+            PATH_EXPR => ExprKind::PathExpr(PathExpr::cast(self.syntax.clone()).unwrap()),
-            LAMBDA_EXPR => ExprKind::LambdaExpr(LambdaExpr::cast(&self.syntax).unwrap()),
+            LAMBDA_EXPR => ExprKind::LambdaExpr(LambdaExpr::cast(self.syntax.clone()).unwrap()),
-            IF_EXPR => ExprKind::IfExpr(IfExpr::cast(&self.syntax).unwrap()),
+            IF_EXPR => ExprKind::IfExpr(IfExpr::cast(self.syntax.clone()).unwrap()),
-            LOOP_EXPR => ExprKind::LoopExpr(LoopExpr::cast(&self.syntax).unwrap()),
+            LOOP_EXPR => ExprKind::LoopExpr(LoopExpr::cast(self.syntax.clone()).unwrap()),
-            FOR_EXPR => ExprKind::ForExpr(ForExpr::cast(&self.syntax).unwrap()),
+            FOR_EXPR => ExprKind::ForExpr(ForExpr::cast(self.syntax.clone()).unwrap()),
-            WHILE_EXPR => ExprKind::WhileExpr(WhileExpr::cast(&self.syntax).unwrap()),
+            WHILE_EXPR => ExprKind::WhileExpr(WhileExpr::cast(self.syntax.clone()).unwrap()),
-            CONTINUE_EXPR => ExprKind::ContinueExpr(ContinueExpr::cast(&self.syntax).unwrap()),
+            CONTINUE_EXPR => ExprKind::ContinueExpr(ContinueExpr::cast(self.syntax.clone()).unwrap()),
-            BREAK_EXPR => ExprKind::BreakExpr(BreakExpr::cast(&self.syntax).unwrap()),
+            BREAK_EXPR => ExprKind::BreakExpr(BreakExpr::cast(self.syntax.clone()).unwrap()),
-            LABEL => ExprKind::Label(Label::cast(&self.syntax).unwrap()),
+            LABEL => ExprKind::Label(Label::cast(self.syntax.clone()).unwrap()),
-            BLOCK_EXPR => ExprKind::BlockExpr(BlockExpr::cast(&self.syntax).unwrap()),
+            BLOCK_EXPR => ExprKind::BlockExpr(BlockExpr::cast(self.syntax.clone()).unwrap()),
-            RETURN_EXPR => ExprKind::ReturnExpr(ReturnExpr::cast(&self.syntax).unwrap()),
+            RETURN_EXPR => ExprKind::ReturnExpr(ReturnExpr::cast(self.syntax.clone()).unwrap()),
-            MATCH_EXPR => ExprKind::MatchExpr(MatchExpr::cast(&self.syntax).unwrap()),
+            MATCH_EXPR => ExprKind::MatchExpr(MatchExpr::cast(self.syntax.clone()).unwrap()),
-            STRUCT_LIT => ExprKind::StructLit(StructLit::cast(&self.syntax).unwrap()),
+            STRUCT_LIT => ExprKind::StructLit(StructLit::cast(self.syntax.clone()).unwrap()),
-            CALL_EXPR => ExprKind::CallExpr(CallExpr::cast(&self.syntax).unwrap()),
+            CALL_EXPR => ExprKind::CallExpr(CallExpr::cast(self.syntax.clone()).unwrap()),
-            INDEX_EXPR => ExprKind::IndexExpr(IndexExpr::cast(&self.syntax).unwrap()),
+            INDEX_EXPR => ExprKind::IndexExpr(IndexExpr::cast(self.syntax.clone()).unwrap()),
-            METHOD_CALL_EXPR => ExprKind::MethodCallExpr(MethodCallExpr::cast(&self.syntax).unwrap()),
+            METHOD_CALL_EXPR => ExprKind::MethodCallExpr(MethodCallExpr::cast(self.syntax.clone()).unwrap()),
-            FIELD_EXPR => ExprKind::FieldExpr(FieldExpr::cast(&self.syntax).unwrap()),
+            FIELD_EXPR => ExprKind::FieldExpr(FieldExpr::cast(self.syntax.clone()).unwrap()),
-            TRY_EXPR => ExprKind::TryExpr(TryExpr::cast(&self.syntax).unwrap()),
+            TRY_EXPR => ExprKind::TryExpr(TryExpr::cast(self.syntax.clone()).unwrap()),
-            TRY_BLOCK_EXPR => ExprKind::TryBlockExpr(TryBlockExpr::cast(&self.syntax).unwrap()),
+            TRY_BLOCK_EXPR => ExprKind::TryBlockExpr(TryBlockExpr::cast(self.syntax.clone()).unwrap()),
-            CAST_EXPR => ExprKind::CastExpr(CastExpr::cast(&self.syntax).unwrap()),
+            CAST_EXPR => ExprKind::CastExpr(CastExpr::cast(self.syntax.clone()).unwrap()),
-            REF_EXPR => ExprKind::RefExpr(RefExpr::cast(&self.syntax).unwrap()),
+            REF_EXPR => ExprKind::RefExpr(RefExpr::cast(self.syntax.clone()).unwrap()),
-            PREFIX_EXPR => ExprKind::PrefixExpr(PrefixExpr::cast(&self.syntax).unwrap()),
+            PREFIX_EXPR => ExprKind::PrefixExpr(PrefixExpr::cast(self.syntax.clone()).unwrap()),
-            RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(&self.syntax).unwrap()),
+            RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(self.syntax.clone()).unwrap()),
-            BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(&self.syntax).unwrap()),
+            BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(self.syntax.clone()).unwrap()),
-            LITERAL => ExprKind::Literal(Literal::cast(&self.syntax).unwrap()),
+            LITERAL => ExprKind::Literal(Literal::cast(self.syntax.clone()).unwrap()),
-            MACRO_CALL => ExprKind::MacroCall(MacroCall::cast(&self.syntax).unwrap()),
+            MACRO_CALL => ExprKind::MacroCall(MacroCall::cast(self.syntax.clone()).unwrap()),
            _ => unreachable!(),
        }
    }
@@ -952,203 +760,149 @@ impl Expr {
 impl Expr {}
 // ExprStmt
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ExprStmt {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ExprStmt {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ExprStmt {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            EXPR_STMT => Some(ExprStmt::from_repr(syntax.into_repr())),
+            EXPR_STMT => Some(ExprStmt { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ExprStmt {
-    type Owned = TreeArc<ExprStmt>;
-    fn to_owned(&self) -> TreeArc<ExprStmt> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ExprStmt {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // ExternCrateItem
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ExternCrateItem {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ExternCrateItem {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ExternCrateItem {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            EXTERN_CRATE_ITEM => Some(ExternCrateItem::from_repr(syntax.into_repr())),
+            EXTERN_CRATE_ITEM => Some(ExternCrateItem { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ExternCrateItem {
-    type Owned = TreeArc<ExternCrateItem>;
-    fn to_owned(&self) -> TreeArc<ExternCrateItem> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ExternCrateItem {
-    pub fn name_ref(&self) -> Option<&NameRef> {
+    pub fn name_ref(&self) -> Option<NameRef> {
        super::child_opt(self)
    }
-    pub fn alias(&self) -> Option<&Alias> {
+    pub fn alias(&self) -> Option<Alias> {
        super::child_opt(self)
    }
 }
 // FieldExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct FieldExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for FieldExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for FieldExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FIELD_EXPR => Some(FieldExpr::from_repr(syntax.into_repr())),
+            FIELD_EXPR => Some(FieldExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for FieldExpr {
-    type Owned = TreeArc<FieldExpr>;
-    fn to_owned(&self) -> TreeArc<FieldExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl FieldExpr {
-    pub fn expr(&self) -> Option<&Expr> {
+    pub fn expr(&self) -> Option<Expr> {
        super::child_opt(self)
    }
-    pub fn name_ref(&self) -> Option<&NameRef> {
+    pub fn name_ref(&self) -> Option<NameRef> {
        super::child_opt(self)
    }
 }
 // FieldPat
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct FieldPat {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for FieldPat {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for FieldPat {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FIELD_PAT => Some(FieldPat::from_repr(syntax.into_repr())),
+            FIELD_PAT => Some(FieldPat { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for FieldPat {
-    type Owned = TreeArc<FieldPat>;
-    fn to_owned(&self) -> TreeArc<FieldPat> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::NameOwner for FieldPat {}
 impl FieldPat {
-    pub fn pat(&self) -> Option<&Pat> {
+    pub fn pat(&self) -> Option<Pat> {
        super::child_opt(self)
    }
 }
 // FieldPatList
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct FieldPatList {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for FieldPatList {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for FieldPatList {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FIELD_PAT_LIST => Some(FieldPatList::from_repr(syntax.into_repr())),
+            FIELD_PAT_LIST => Some(FieldPatList { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for FieldPatList {
-    type Owned = TreeArc<FieldPatList>;
-    fn to_owned(&self) -> TreeArc<FieldPatList> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl FieldPatList {
-    pub fn field_pats(&self) -> impl Iterator<Item = &FieldPat> {
+    pub fn field_pats(&self) -> impl Iterator<Item = FieldPat> {
        super::children(self)
    }
-    pub fn bind_pats(&self) -> impl Iterator<Item = &BindPat> {
+    pub fn bind_pats(&self) -> impl Iterator<Item = BindPat> {
        super::children(self)
    }
 }
 // FnDef
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct FnDef {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for FnDef {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for FnDef {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FN_DEF => Some(FnDef::from_repr(syntax.into_repr())),
+            FN_DEF => Some(FnDef { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for FnDef {
-    type Owned = TreeArc<FnDef>;
-    fn to_owned(&self) -> TreeArc<FnDef> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::VisibilityOwner for FnDef {}
 impl ast::NameOwner for FnDef {}
@@ -1156,246 +910,192 @@ impl ast::TypeParamsOwner for FnDef {}
 impl ast::AttrsOwner for FnDef {}
 impl ast::DocCommentsOwner for FnDef {}
 impl FnDef {
-    pub fn param_list(&self) -> Option<&ParamList> {
+    pub fn param_list(&self) -> Option<ParamList> {
        super::child_opt(self)
    }
-    pub fn body(&self) -> Option<&Block> {
+    pub fn body(&self) -> Option<Block> {
        super::child_opt(self)
    }
-    pub fn ret_type(&self) -> Option<&RetType> {
+    pub fn ret_type(&self) -> Option<RetType> {
        super::child_opt(self)
    }
 }
 // FnPointerType
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct FnPointerType {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for FnPointerType {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for FnPointerType {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FN_POINTER_TYPE => Some(FnPointerType::from_repr(syntax.into_repr())),
+            FN_POINTER_TYPE => Some(FnPointerType { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for FnPointerType {
-    type Owned = TreeArc<FnPointerType>;
-    fn to_owned(&self) -> TreeArc<FnPointerType> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl FnPointerType {
-    pub fn param_list(&self) -> Option<&ParamList> {
+    pub fn param_list(&self) -> Option<ParamList> {
        super::child_opt(self)
    }
-    pub fn ret_type(&self) -> Option<&RetType> {
+    pub fn ret_type(&self) -> Option<RetType> {
        super::child_opt(self)
    }
 }
 // ForExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ForExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ForExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ForExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FOR_EXPR => Some(ForExpr::from_repr(syntax.into_repr())),
+            FOR_EXPR => Some(ForExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ForExpr {
-    type Owned = TreeArc<ForExpr>;
-    fn to_owned(&self) -> TreeArc<ForExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::LoopBodyOwner for ForExpr {}
 impl ForExpr {
-    pub fn pat(&self) -> Option<&Pat> {
+    pub fn pat(&self) -> Option<Pat> {
        super::child_opt(self)
    }
-    pub fn iterable(&self) -> Option<&Expr> {
+    pub fn iterable(&self) -> Option<Expr> {
        super::child_opt(self)
    }
 }
 // ForType
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ForType {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ForType {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ForType {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            FOR_TYPE => Some(ForType::from_repr(syntax.into_repr())),
+            FOR_TYPE => Some(ForType { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ForType {
-    type Owned = TreeArc<ForType>;
-    fn to_owned(&self) -> TreeArc<ForType> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ForType {
-    pub fn type_ref(&self) -> Option<&TypeRef> {
+    pub fn type_ref(&self) -> Option<TypeRef> {
        super::child_opt(self)
    }
 }
 // IfExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct IfExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for IfExpr {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for IfExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            IF_EXPR => Some(IfExpr::from_repr(syntax.into_repr())),
+            IF_EXPR => Some(IfExpr { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for IfExpr {
-    type Owned = TreeArc<IfExpr>;
-    fn to_owned(&self) -> TreeArc<IfExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl IfExpr {
-    pub fn condition(&self) -> Option<&Condition> {
+    pub fn condition(&self) -> Option<Condition> {
        super::child_opt(self)
    }
 }
 // ImplBlock
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
 pub struct ImplBlock {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for ImplBlock {
-    type Repr = rowan::SyntaxNode;
-}
 impl AstNode for ImplBlock {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match syntax.kind() {
-            IMPL_BLOCK => Some(ImplBlock::from_repr(syntax.into_repr())),
+            IMPL_BLOCK => Some(ImplBlock { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for ImplBlock {
-    type Owned = TreeArc<ImplBlock>;
-    fn to_owned(&self) -> TreeArc<ImplBlock> { TreeArc::cast(self.syntax.to_owned()) }
-}
 impl ast::TypeParamsOwner for ImplBlock {}
author	bors[bot] <26634292+bors[bot]@users.noreply.github.com>	2019-07-19 12:15:55 +0100
committer	bors[bot] <26634292+bors[bot]@users.noreply.github.com>	2019-07-19 12:15:55 +0100
commit	f209843e31af7f0e0212aa28ffec2efad2a70c6f (patch)
tree	548227da78a3bea644f57714d075410c0bdf7469 /crates
parent	58d4983ba5745975446d60f2886d96f8d2adf0f2 (diff)
parent	d4a66166c002f0a49e41d856a49cb5685ac93202 (diff)