1 files changed, 65 insertions, 58 deletions

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>,
-    ast: TreeArc<N>,
+    original_ast: N,
+    ast: N,
 }
 
 impl<N: AstNode> AstEditor<N> {
-    pub fn new(node: &N) -> AstEditor<N> {
-        AstEditor { original_ast: node.to_owned(), ast: node.to_owned() }
+    pub fn new(node: N) -> AstEditor<N> {
+        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<'_>>,
-        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
-    ) -> TreeArc<N> {
+        position: InsertPosition<SyntaxElement>,
+        to_insert: impl Iterator<Item = SyntaxElement>,
+    ) -> 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_insert: impl Iterator<Item = SyntaxElement<'a>>,
-    ) -> TreeArc<N> {
+        to_delete: RangeInclusive<SyntaxElement>,
+        to_insert: impl Iterator<Item = SyntaxElement>,
+    ) -> 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(),
-                InsertPosition::After(it.syntax().into()),
+                leading_indent(it.syntax()).unwrap_or_default().to_string(),
+                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() {
-                Some(el) if el.kind() == WHITESPACE => el,
-                Some(_) | None => start,
+            let end = match &start.next_sibling_or_token() {
+                Some(el) if el.kind() == WHITESPACE => el.clone(),
+                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());
-        let replace_range = RangeInclusive::new(old_body_or_semi, old_body_or_semi);
+        to_insert.push(body.syntax().clone().into());
+        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>> =
-        Lazy::new(|| SourceFile::parse(",\n; ;").tree().to_owned());
+    static SOURCE_FILE: Lazy<Parse<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;"));
 
-    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<'_> {
-            self.0.syntax().first_child_or_token().unwrap().as_token().unwrap()
+        pub(crate) fn ws(&self) -> SyntaxToken {
+            self.0.syntax().first_child_or_token().unwrap().as_token().cloned().unwrap()
         }
     }