migrate ra_syntax to the new rowan API

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:
-    rowan::TransparentNewType<Repr = rowan::SyntaxNode> + ToOwned<Owned = TreeArc<Self>>
-{
-    fn cast(syntax: &SyntaxNode) -> Option<&Self>
+pub trait AstNode {
+    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> {
-    fn cast(token: SyntaxToken<'a>) -> Option<Self>
+pub trait AstToken {
+    fn cast(token: SyntaxToken) -> Option<Self>
     where
         Self: Sized;
-    fn syntax(&self) -> SyntaxToken<'a>;
-    fn text(&self) -> &'a SmolStr {
+    fn syntax(&self) -> &SyntaxToken;
+    fn text(&self) -> &SmolStr {
         self.syntax().text()
     }
 }
 
 /// An iterator over `SyntaxNode` children of a particular AST type.
 #[derive(Debug)]
-pub struct AstChildren<'a, N> {
-    inner: SyntaxNodeChildren<'a>,
+pub struct AstChildren<N> {
+    inner: SyntaxNodeChildren,
     ph: PhantomData<N>,
 }
 
-impl<'a, N> AstChildren<'a, N> {
-    fn new(parent: &'a SyntaxNode) -> Self {
+impl<N> AstChildren<N> {
+    fn new(parent: &SyntaxNode) -> Self {
         AstChildren { inner: parent.children(), ph: PhantomData }
     }
 }
 
-impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
-    type Item = &'a N;
-    fn next(&mut self) -> Option<&'a N> {
+impl<N: AstNode> Iterator for AstChildren<N> {
+    type Item = 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());
     }