207 files changed, 3703 insertions, 2334 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index de4b25e67..54ee72386 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -8,11 +8,12 @@ description = "Comment and whitespace preserving parser for the Rust langauge"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 
 [dependencies]
+arrayvec = "0.4.7"
 unicode-xid = "0.1.0"
 itertools = "0.7.8"
 drop_bomb = "0.1.4"
 parking_lot = "0.6.0"
-rowan = "0.1.1"
+rowan = "0.1.2"
 text_unit = "0.1.5"
 
 [dev-dependencies]
diff --git a/crates/ra_syntax/src/algo/mod.rs b/crates/ra_syntax/src/algo/mod.rs
index faf5a6211..4b3548ea9 100644
--- a/crates/ra_syntax/src/algo/mod.rs
+++ b/crates/ra_syntax/src/algo/mod.rs
@@ -1,116 +1,19 @@
 pub mod visit;
-// pub mod walk;
 
-use crate::{text_utils::contains_offset_nonstrict, SyntaxNodeRef, TextRange, TextUnit};
+use crate::{SyntaxNode, SyntaxNodeRef, TextRange, TextUnit};
 
-pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset {
-    let range = node.range();
-    assert!(
-        contains_offset_nonstrict(range, offset),
-        "Bad offset: range {:?} offset {:?}",
-        range,
-        offset
-    );
-    if range.is_empty() {
-        return LeafAtOffset::None;
-    }
-
-    if node.is_leaf() {
-        return LeafAtOffset::Single(node);
-    }
-
-    let mut children = node.children().filter(|child| {
-        let child_range = child.range();
-        !child_range.is_empty() && contains_offset_nonstrict(child_range, offset)
-    });
-
-    let left = children.next().unwrap();
-    let right = children.next();
-    assert!(children.next().is_none());
-
-    if let Some(right) = right {
-        match (
-            find_leaf_at_offset(left, offset),
-            find_leaf_at_offset(right, offset),
-        ) {
-            (LeafAtOffset::Single(left), LeafAtOffset::Single(right)) => {
-                LeafAtOffset::Between(left, right)
-            }
-            _ => unreachable!(),
-        }
-    } else {
-        find_leaf_at_offset(left, offset)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum LeafAtOffset<'a> {
-    None,
-    Single(SyntaxNodeRef<'a>),
-    Between(SyntaxNodeRef<'a>, SyntaxNodeRef<'a>),
-}
+pub use rowan::LeafAtOffset;
 
-impl<'a> LeafAtOffset<'a> {
-    pub fn right_biased(self) -> Option<SyntaxNodeRef<'a>> {
-        match self {
-            LeafAtOffset::None => None,
-            LeafAtOffset::Single(node) => Some(node),
-            LeafAtOffset::Between(_, right) => Some(right),
-        }
-    }
-
-    pub fn left_biased(self) -> Option<SyntaxNodeRef<'a>> {
-        match self {
-            LeafAtOffset::None => None,
-            LeafAtOffset::Single(node) => Some(node),
-            LeafAtOffset::Between(left, _) => Some(left),
-        }
-    }
-}
-
-impl<'f> Iterator for LeafAtOffset<'f> {
-    type Item = SyntaxNodeRef<'f>;
-
-    fn next(&mut self) -> Option<SyntaxNodeRef<'f>> {
-        match *self {
-            LeafAtOffset::None => None,
-            LeafAtOffset::Single(node) => {
-                *self = LeafAtOffset::None;
-                Some(node)
-            }
-            LeafAtOffset::Between(left, right) => {
-                *self = LeafAtOffset::Single(right);
-                Some(left)
-            }
-        }
+pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset<SyntaxNodeRef> {
+    match node.0.leaf_at_offset(offset) {
+        LeafAtOffset::None => LeafAtOffset::None,
+        LeafAtOffset::Single(n) => LeafAtOffset::Single(SyntaxNode(n)),
+        LeafAtOffset::Between(l, r) => LeafAtOffset::Between(SyntaxNode(l), SyntaxNode(r)),
     }
 }
 
 pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
-    assert!(
-        range.is_subrange(&root.range()),
-        "node range: {:?}, target range: {:?}",
-        root.range(),
-        range,
-    );
-    let (left, right) = match (
-        find_leaf_at_offset(root, range.start()).right_biased(),
-        find_leaf_at_offset(root, range.end()).left_biased(),
-    ) {
-        (Some(l), Some(r)) => (l, r),
-        _ => return root,
-    };
-
-    common_ancestor(left, right)
-}
-
-fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
-    for p in n1.ancestors() {
-        if n2.ancestors().any(|a| a == p) {
-            return p;
-        }
-    }
-    panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
+    SyntaxNode(root.0.covering_node(range))
 }
 
 pub fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item = T> {
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 75769a4e9..bf056131e 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,34 +1,36 @@
 // This file is automatically generated based on the file `./generated.rs.tera` when `cargo gen-syntax` is run
 // Do not edit manually
 
+//! This module contains auto-generated Rust AST. Like `SyntaxNode`s, AST nodes
+//! are generic over ownership: `X<'a>` things are `Copy` references, `XNode`
+//! are Arc-based. You can switch between the two variants using `.owned` and
+//! `.borrowed` functions. Most of the code works with borowed mode, and only
+//! this mode has all AST accessors.
+
 #![cfg_attr(rustfmt, rustfmt_skip)]
 
+use std::hash::{Hash, Hasher};
+
 use crate::{
     ast,
     SyntaxNode, SyntaxNodeRef, AstNode,
+    yellow::{TreeRoot, RaTypes, OwnedRoot, RefRoot},
     SyntaxKind::*,
 };
 
 // ArgList
-
-#[derive(Debug, Clone)]
-pub struct ArgListNode(SyntaxNode);
-
-impl ArgListNode {
-    pub fn ast(&self) -> ArgList {
-        ArgList::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ArgListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ArgList<'a> = ArgListNode<RefRoot<'a>>;
 
-impl<'a> From<ArgList<'a>> for ArgListNode {
-    fn from(ast: ArgList<'a>) -> ArgListNode {
-        let syntax = ast.syntax().owned();
-        ArgListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArgListNode<R1>> for ArgListNode<R2> {
+    fn eq(&self, other: &ArgListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ArgList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ArgListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArgListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ArgList<'a> {
@@ -41,6 +43,16 @@ impl<'a> AstNode<'a> for ArgList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ArgListNode<R> {
+    pub fn borrowed(&self) -> ArgList {
+        ArgListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ArgListNode {
+        ArgListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ArgList<'a> {
     pub fn args(self) -> impl Iterator<Item = Expr<'a>> + 'a {
         super::children(self)
@@ -48,25 +60,18 @@ impl<'a> ArgList<'a> {
 }
 
 // ArrayExpr
-
-#[derive(Debug, Clone)]
-pub struct ArrayExprNode(SyntaxNode);
-
-impl ArrayExprNode {
-    pub fn ast(&self) -> ArrayExpr {
-        ArrayExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ArrayExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ArrayExpr<'a> = ArrayExprNode<RefRoot<'a>>;
 
-impl<'a> From<ArrayExpr<'a>> for ArrayExprNode {
-    fn from(ast: ArrayExpr<'a>) -> ArrayExprNode {
-        let syntax = ast.syntax().owned();
-        ArrayExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayExprNode<R1>> for ArrayExprNode<R2> {
+    fn eq(&self, other: &ArrayExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ArrayExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ArrayExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArrayExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ArrayExpr<'a> {
@@ -79,28 +84,31 @@ impl<'a> AstNode<'a> for ArrayExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ArrayExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> ArrayExprNode<R> {
+    pub fn borrowed(&self) -> ArrayExpr {
+        ArrayExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ArrayExprNode {
+        ArrayExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// ArrayType
 
-#[derive(Debug, Clone)]
-pub struct ArrayTypeNode(SyntaxNode);
+impl<'a> ArrayExpr<'a> {}
 
-impl ArrayTypeNode {
-    pub fn ast(&self) -> ArrayType {
-        ArrayType::cast(self.0.borrowed()).unwrap()
-    }
+// ArrayType
+#[derive(Debug, Clone, Copy,)]
+pub struct ArrayTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ArrayType<'a> = ArrayTypeNode<RefRoot<'a>>;
 
-impl<'a> From<ArrayType<'a>> for ArrayTypeNode {
-    fn from(ast: ArrayType<'a>) -> ArrayTypeNode {
-        let syntax = ast.syntax().owned();
-        ArrayTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayTypeNode<R1>> for ArrayTypeNode<R2> {
+    fn eq(&self, other: &ArrayTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ArrayType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ArrayTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArrayTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ArrayType<'a> {
@@ -113,28 +121,31 @@ impl<'a> AstNode<'a> for ArrayType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ArrayType<'a> {}
+impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> {
+    pub fn borrowed(&self) -> ArrayType {
+        ArrayTypeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ArrayTypeNode {
+        ArrayTypeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// Attr
 
-#[derive(Debug, Clone)]
-pub struct AttrNode(SyntaxNode);
+impl<'a> ArrayType<'a> {}
 
-impl AttrNode {
-    pub fn ast(&self) -> Attr {
-        Attr::cast(self.0.borrowed()).unwrap()
-    }
+// Attr
+#[derive(Debug, Clone, Copy,)]
+pub struct AttrNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Attr<'a> = AttrNode<RefRoot<'a>>;
 
-impl<'a> From<Attr<'a>> for AttrNode {
-    fn from(ast: Attr<'a>) -> AttrNode {
-        let syntax = ast.syntax().owned();
-        AttrNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<AttrNode<R1>> for AttrNode<R2> {
+    fn eq(&self, other: &AttrNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Attr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for AttrNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for AttrNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Attr<'a> {
@@ -147,6 +158,16 @@ impl<'a> AstNode<'a> for Attr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> AttrNode<R> {
+    pub fn borrowed(&self) -> Attr {
+        AttrNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> AttrNode {
+        AttrNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> Attr<'a> {
     pub fn value(self) -> Option<TokenTree<'a>> {
         super::child_opt(self)
@@ -154,25 +175,18 @@ impl<'a> Attr<'a> {
 }
 
 // BinExpr
-
-#[derive(Debug, Clone)]
-pub struct BinExprNode(SyntaxNode);
-
-impl BinExprNode {
-    pub fn ast(&self) -> BinExpr {
-        BinExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct BinExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type BinExpr<'a> = BinExprNode<RefRoot<'a>>;
 
-impl<'a> From<BinExpr<'a>> for BinExprNode {
-    fn from(ast: BinExpr<'a>) -> BinExprNode {
-        let syntax = ast.syntax().owned();
-        BinExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BinExprNode<R1>> for BinExprNode<R2> {
+    fn eq(&self, other: &BinExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct BinExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for BinExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BinExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for BinExpr<'a> {
@@ -185,28 +199,31 @@ impl<'a> AstNode<'a> for BinExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> BinExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> BinExprNode<R> {
+    pub fn borrowed(&self) -> BinExpr {
+        BinExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> BinExprNode {
+        BinExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// BindPat
 
-#[derive(Debug, Clone)]
-pub struct BindPatNode(SyntaxNode);
+impl<'a> BinExpr<'a> {}
 
-impl BindPatNode {
-    pub fn ast(&self) -> BindPat {
-        BindPat::cast(self.0.borrowed()).unwrap()
-    }
+// BindPat
+#[derive(Debug, Clone, Copy,)]
+pub struct BindPatNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type BindPat<'a> = BindPatNode<RefRoot<'a>>;
 
-impl<'a> From<BindPat<'a>> for BindPatNode {
-    fn from(ast: BindPat<'a>) -> BindPatNode {
-        let syntax = ast.syntax().owned();
-        BindPatNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BindPatNode<R1>> for BindPatNode<R2> {
+    fn eq(&self, other: &BindPatNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct BindPat<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for BindPatNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BindPatNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for BindPat<'a> {
@@ -219,29 +236,32 @@ impl<'a> AstNode<'a> for BindPat<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> BindPatNode<R> {
+    pub fn borrowed(&self) -> BindPat {
+        BindPatNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> BindPatNode {
+        BindPatNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for BindPat<'a> {}
 impl<'a> BindPat<'a> {}
 
 // Block
-
-#[derive(Debug, Clone)]
-pub struct BlockNode(SyntaxNode);
-
-impl BlockNode {
-    pub fn ast(&self) -> Block {
-        Block::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct BlockNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Block<'a> = BlockNode<RefRoot<'a>>;
 
-impl<'a> From<Block<'a>> for BlockNode {
-    fn from(ast: Block<'a>) -> BlockNode {
-        let syntax = ast.syntax().owned();
-        BlockNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockNode<R1>> for BlockNode<R2> {
+    fn eq(&self, other: &BlockNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Block<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for BlockNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BlockNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Block<'a> {
@@ -254,6 +274,16 @@ impl<'a> AstNode<'a> for Block<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> BlockNode<R> {
+    pub fn borrowed(&self) -> Block {
+        BlockNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> BlockNode {
+        BlockNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> Block<'a> {
     pub fn statements(self) -> impl Iterator<Item = Stmt<'a>> + 'a {
         super::children(self)
@@ -265,25 +295,18 @@ impl<'a> Block<'a> {
 }
 
 // BlockExpr
-
-#[derive(Debug, Clone)]
-pub struct BlockExprNode(SyntaxNode);
-
-impl BlockExprNode {
-    pub fn ast(&self) -> BlockExpr {
-        BlockExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct BlockExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type BlockExpr<'a> = BlockExprNode<RefRoot<'a>>;
 
-impl<'a> From<BlockExpr<'a>> for BlockExprNode {
-    fn from(ast: BlockExpr<'a>) -> BlockExprNode {
-        let syntax = ast.syntax().owned();
-        BlockExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockExprNode<R1>> for BlockExprNode<R2> {
+    fn eq(&self, other: &BlockExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct BlockExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for BlockExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BlockExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for BlockExpr<'a> {
@@ -296,6 +319,16 @@ impl<'a> AstNode<'a> for BlockExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> BlockExprNode<R> {
+    pub fn borrowed(&self) -> BlockExpr {
+        BlockExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> BlockExprNode {
+        BlockExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> BlockExpr<'a> {
     pub fn block(self) -> Option<Block<'a>> {
         super::child_opt(self)
@@ -303,59 +336,129 @@ impl<'a> BlockExpr<'a> {
 }
 
 // BreakExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct BreakExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type BreakExpr<'a> = BreakExprNode<RefRoot<'a>>;
 
-#[derive(Debug, Clone)]
-pub struct BreakExprNode(SyntaxNode);
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BreakExprNode<R1>> for BreakExprNode<R2> {
+    fn eq(&self, other: &BreakExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BreakExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BreakExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
 
-impl BreakExprNode {
-    pub fn ast(&self) -> BreakExpr {
-        BreakExpr::cast(self.0.borrowed()).unwrap()
+impl<'a> AstNode<'a> for BreakExpr<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BREAK_EXPR => Some(BreakExpr { syntax }),
+            _ => None,
+        }
     }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> From<BreakExpr<'a>> for BreakExprNode {
-    fn from(ast: BreakExpr<'a>) -> BreakExprNode {
-        let syntax = ast.syntax().owned();
-        BreakExprNode(syntax)
+impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
+    pub fn borrowed(&self) -> BreakExpr {
+        BreakExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> BreakExprNode {
+        BreakExprNode { syntax: self.syntax.owned() }
     }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct BreakExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+
+
+impl<'a> BreakExpr<'a> {}
+
+// Byte
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Byte<'a> = ByteNode<RefRoot<'a>>;
 
-impl<'a> AstNode<'a> for BreakExpr<'a> {
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteNode<R1>> for ByteNode<R2> {
+    fn eq(&self, other: &ByteNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for Byte<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
-            BREAK_EXPR => Some(BreakExpr { syntax }),
+            BYTE => Some(Byte { syntax }),
             _ => None,
         }
     }
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> BreakExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> ByteNode<R> {
+    pub fn borrowed(&self) -> Byte {
+        ByteNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ByteNode {
+        ByteNode { syntax: self.syntax.owned() }
+    }
+}
 
-// CallExpr
 
-#[derive(Debug, Clone)]
-pub struct CallExprNode(SyntaxNode);
+impl<'a> Byte<'a> {}
+
+// ByteString
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteStringNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type ByteString<'a> = ByteStringNode<RefRoot<'a>>;
 
-impl CallExprNode {
-    pub fn ast(&self) -> CallExpr {
-        CallExpr::cast(self.0.borrowed()).unwrap()
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteStringNode<R1>> for ByteStringNode<R2> {
+    fn eq(&self, other: &ByteStringNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteStringNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteStringNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for ByteString<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BYTE_STRING => Some(ByteString { syntax }),
+            _ => None,
+        }
     }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> From<CallExpr<'a>> for CallExprNode {
-    fn from(ast: CallExpr<'a>) -> CallExprNode {
-        let syntax = ast.syntax().owned();
-        CallExprNode(syntax)
+impl<R: TreeRoot<RaTypes>> ByteStringNode<R> {
+    pub fn borrowed(&self) -> ByteString {
+        ByteStringNode { syntax: self.syntax.borrowed() }
     }
+    pub fn owned(&self) -> ByteStringNode {
+        ByteStringNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> ByteString<'a> {}
+
+// CallExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
-#[derive(Debug, Clone, Copy)]
-pub struct CallExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+pub type CallExpr<'a> = CallExprNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CallExprNode<R1>> for CallExprNode<R2> {
+    fn eq(&self, other: &CallExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for CallExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CallExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for CallExpr<'a> {
@@ -368,6 +471,16 @@ impl<'a> AstNode<'a> for CallExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> CallExprNode<R> {
+    pub fn borrowed(&self) -> CallExpr {
+        CallExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> CallExprNode {
+        CallExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::ArgListOwner<'a> for CallExpr<'a> {}
 impl<'a> CallExpr<'a> {
     pub fn expr(self) -> Option<Expr<'a>> {
@@ -376,25 +489,18 @@ impl<'a> CallExpr<'a> {
 }
 
 // CastExpr
-
-#[derive(Debug, Clone)]
-pub struct CastExprNode(SyntaxNode);
-
-impl CastExprNode {
-    pub fn ast(&self) -> CastExpr {
-        CastExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct CastExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type CastExpr<'a> = CastExprNode<RefRoot<'a>>;
 
-impl<'a> From<CastExpr<'a>> for CastExprNode {
-    fn from(ast: CastExpr<'a>) -> CastExprNode {
-        let syntax = ast.syntax().owned();
-        CastExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CastExprNode<R1>> for CastExprNode<R2> {
+    fn eq(&self, other: &CastExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct CastExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for CastExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CastExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for CastExpr<'a> {
@@ -407,28 +513,31 @@ impl<'a> AstNode<'a> for CastExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> CastExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> CastExprNode<R> {
+    pub fn borrowed(&self) -> CastExpr {
+        CastExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> CastExprNode {
+        CastExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// Char
 
-#[derive(Debug, Clone)]
-pub struct CharNode(SyntaxNode);
+impl<'a> CastExpr<'a> {}
 
-impl CharNode {
-    pub fn ast(&self) -> Char {
-        Char::cast(self.0.borrowed()).unwrap()
-    }
+// Char
+#[derive(Debug, Clone, Copy,)]
+pub struct CharNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Char<'a> = CharNode<RefRoot<'a>>;
 
-impl<'a> From<Char<'a>> for CharNode {
-    fn from(ast: Char<'a>) -> CharNode {
-        let syntax = ast.syntax().owned();
-        CharNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CharNode<R1>> for CharNode<R2> {
+    fn eq(&self, other: &CharNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Char<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for CharNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CharNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Char<'a> {
@@ -441,28 +550,31 @@ impl<'a> AstNode<'a> for Char<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Char<'a> {}
+impl<R: TreeRoot<RaTypes>> CharNode<R> {
+    pub fn borrowed(&self) -> Char {
+        CharNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> CharNode {
+        CharNode { syntax: self.syntax.owned() }
+    }
+}
 
-// Comment
 
-#[derive(Debug, Clone)]
-pub struct CommentNode(SyntaxNode);
+impl<'a> Char<'a> {}
 
-impl CommentNode {
-    pub fn ast(&self) -> Comment {
-        Comment::cast(self.0.borrowed()).unwrap()
-    }
+// Comment
+#[derive(Debug, Clone, Copy,)]
+pub struct CommentNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Comment<'a> = CommentNode<RefRoot<'a>>;
 
-impl<'a> From<Comment<'a>> for CommentNode {
-    fn from(ast: Comment<'a>) -> CommentNode {
-        let syntax = ast.syntax().owned();
-        CommentNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CommentNode<R1>> for CommentNode<R2> {
+    fn eq(&self, other: &CommentNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Comment<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for CommentNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CommentNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Comment<'a> {
@@ -475,28 +587,31 @@ impl<'a> AstNode<'a> for Comment<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Comment<'a> {}
+impl<R: TreeRoot<RaTypes>> CommentNode<R> {
+    pub fn borrowed(&self) -> Comment {
+        CommentNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> CommentNode {
+        CommentNode { syntax: self.syntax.owned() }
+    }
+}
 
-// Condition
 
-#[derive(Debug, Clone)]
-pub struct ConditionNode(SyntaxNode);
+impl<'a> Comment<'a> {}
 
-impl ConditionNode {
-    pub fn ast(&self) -> Condition {
-        Condition::cast(self.0.borrowed()).unwrap()
-    }
+// Condition
+#[derive(Debug, Clone, Copy,)]
+pub struct ConditionNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Condition<'a> = ConditionNode<RefRoot<'a>>;
 
-impl<'a> From<Condition<'a>> for ConditionNode {
-    fn from(ast: Condition<'a>) -> ConditionNode {
-        let syntax = ast.syntax().owned();
-        ConditionNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConditionNode<R1>> for ConditionNode<R2> {
+    fn eq(&self, other: &ConditionNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Condition<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ConditionNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ConditionNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Condition<'a> {
@@ -509,6 +624,16 @@ impl<'a> AstNode<'a> for Condition<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ConditionNode<R> {
+    pub fn borrowed(&self) -> Condition {
+        ConditionNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ConditionNode {
+        ConditionNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> Condition<'a> {
     pub fn pat(self) -> Option<Pat<'a>> {
         super::child_opt(self)
@@ -520,25 +645,18 @@ impl<'a> Condition<'a> {
 }
 
 // ConstDef
-
-#[derive(Debug, Clone)]
-pub struct ConstDefNode(SyntaxNode);
-
-impl ConstDefNode {
-    pub fn ast(&self) -> ConstDef {
-        ConstDef::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ConstDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ConstDef<'a> = ConstDefNode<RefRoot<'a>>;
 
-impl<'a> From<ConstDef<'a>> for ConstDefNode {
-    fn from(ast: ConstDef<'a>) -> ConstDefNode {
-        let syntax = ast.syntax().owned();
-        ConstDefNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConstDefNode<R1>> for ConstDefNode<R2> {
+    fn eq(&self, other: &ConstDefNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ConstDef<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ConstDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ConstDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ConstDef<'a> {
@@ -551,31 +669,35 @@ impl<'a> AstNode<'a> for ConstDef<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ConstDefNode<R> {
+    pub fn borrowed(&self) -> ConstDef {
+        ConstDefNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ConstDefNode {
+        ConstDefNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {}
+impl<'a> ast::DocCommentsOwner<'a> for ConstDef<'a> {}
 impl<'a> ConstDef<'a> {}
 
 // ContinueExpr
-
-#[derive(Debug, Clone)]
-pub struct ContinueExprNode(SyntaxNode);
-
-impl ContinueExprNode {
-    pub fn ast(&self) -> ContinueExpr {
-        ContinueExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ContinueExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ContinueExpr<'a> = ContinueExprNode<RefRoot<'a>>;
 
-impl<'a> From<ContinueExpr<'a>> for ContinueExprNode {
-    fn from(ast: ContinueExpr<'a>) -> ContinueExprNode {
-        let syntax = ast.syntax().owned();
-        ContinueExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ContinueExprNode<R1>> for ContinueExprNode<R2> {
+    fn eq(&self, other: &ContinueExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ContinueExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ContinueExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ContinueExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ContinueExpr<'a> {
@@ -588,28 +710,31 @@ impl<'a> AstNode<'a> for ContinueExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ContinueExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> ContinueExprNode<R> {
+    pub fn borrowed(&self) -> ContinueExpr {
+        ContinueExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ContinueExprNode {
+        ContinueExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// DynTraitType
 
-#[derive(Debug, Clone)]
-pub struct DynTraitTypeNode(SyntaxNode);
+impl<'a> ContinueExpr<'a> {}
 
-impl DynTraitTypeNode {
-    pub fn ast(&self) -> DynTraitType {
-        DynTraitType::cast(self.0.borrowed()).unwrap()
-    }
+// DynTraitType
+#[derive(Debug, Clone, Copy,)]
+pub struct DynTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type DynTraitType<'a> = DynTraitTypeNode<RefRoot<'a>>;
 
-impl<'a> From<DynTraitType<'a>> for DynTraitTypeNode {
-    fn from(ast: DynTraitType<'a>) -> DynTraitTypeNode {
-        let syntax = ast.syntax().owned();
-        DynTraitTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<DynTraitTypeNode<R1>> for DynTraitTypeNode<R2> {
+    fn eq(&self, other: &DynTraitTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct DynTraitType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for DynTraitTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for DynTraitTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for DynTraitType<'a> {
@@ -622,28 +747,31 @@ impl<'a> AstNode<'a> for DynTraitType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> DynTraitType<'a> {}
+impl<R: TreeRoot<RaTypes>> DynTraitTypeNode<R> {
+    pub fn borrowed(&self) -> DynTraitType {
+        DynTraitTypeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> DynTraitTypeNode {
+        DynTraitTypeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// EnumDef
 
-#[derive(Debug, Clone)]
-pub struct EnumDefNode(SyntaxNode);
+impl<'a> DynTraitType<'a> {}
 
-impl EnumDefNode {
-    pub fn ast(&self) -> EnumDef {
-        EnumDef::cast(self.0.borrowed()).unwrap()
-    }
+// EnumDef
+#[derive(Debug, Clone, Copy,)]
+pub struct EnumDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type EnumDef<'a> = EnumDefNode<RefRoot<'a>>;
 
-impl<'a> From<EnumDef<'a>> for EnumDefNode {
-    fn from(ast: EnumDef<'a>) -> EnumDefNode {
-        let syntax = ast.syntax().owned();
-        EnumDefNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumDefNode<R1>> for EnumDefNode<R2> {
+    fn eq(&self, other: &EnumDefNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct EnumDef<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for EnumDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for EnumDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for EnumDef<'a> {
@@ -656,29 +784,24 @@ impl<'a> AstNode<'a> for EnumDef<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> EnumDefNode<R> {
+    pub fn borrowed(&self) -> EnumDef {
+        EnumDefNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> EnumDefNode {
+        EnumDefNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
+impl<'a> ast::DocCommentsOwner<'a> for EnumDef<'a> {}
 impl<'a> EnumDef<'a> {}
 
 // Expr
-
-#[derive(Debug, Clone)]
-pub struct ExprNode(SyntaxNode);
-
-impl ExprNode {
-    pub fn ast(&self) -> Expr {
-        Expr::cast(self.0.borrowed()).unwrap()
-    }
-}
-
-impl<'a> From<Expr<'a>> for ExprNode {
-    fn from(ast: Expr<'a>) -> ExprNode {
-        let syntax = ast.syntax().owned();
-        ExprNode(syntax)
-    }
-}
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Expr<'a> {
     TupleExpr(TupleExpr<'a>),
     ArrayExpr(ArrayExpr<'a>),
@@ -793,25 +916,18 @@ impl<'a> AstNode<'a> for Expr<'a> {
 impl<'a> Expr<'a> {}
 
 // ExprStmt
-
-#[derive(Debug, Clone)]
-pub struct ExprStmtNode(SyntaxNode);
-
-impl ExprStmtNode {
-    pub fn ast(&self) -> ExprStmt {
-        ExprStmt::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ExprStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ExprStmt<'a> = ExprStmtNode<RefRoot<'a>>;
 
-impl<'a> From<ExprStmt<'a>> for ExprStmtNode {
-    fn from(ast: ExprStmt<'a>) -> ExprStmtNode {
-        let syntax = ast.syntax().owned();
-        ExprStmtNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExprStmtNode<R1>> for ExprStmtNode<R2> {
+    fn eq(&self, other: &ExprStmtNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ExprStmt<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ExprStmtNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ExprStmtNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ExprStmt<'a> {
@@ -824,6 +940,16 @@ impl<'a> AstNode<'a> for ExprStmt<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ExprStmtNode<R> {
+    pub fn borrowed(&self) -> ExprStmt {
+        ExprStmtNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ExprStmtNode {
+        ExprStmtNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ExprStmt<'a> {
     pub fn expr(self) -> Option<Expr<'a>> {
         super::child_opt(self)
@@ -831,25 +957,18 @@ impl<'a> ExprStmt<'a> {
 }
 
 // ExternCrateItem
-
-#[derive(Debug, Clone)]
-pub struct ExternCrateItemNode(SyntaxNode);
-
-impl ExternCrateItemNode {
-    pub fn ast(&self) -> ExternCrateItem {
-        ExternCrateItem::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ExternCrateItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ExternCrateItem<'a> = ExternCrateItemNode<RefRoot<'a>>;
 
-impl<'a> From<ExternCrateItem<'a>> for ExternCrateItemNode {
-    fn from(ast: ExternCrateItem<'a>) -> ExternCrateItemNode {
-        let syntax = ast.syntax().owned();
-        ExternCrateItemNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExternCrateItemNode<R1>> for ExternCrateItemNode<R2> {
+    fn eq(&self, other: &ExternCrateItemNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ExternCrateItem<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ExternCrateItemNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ExternCrateItemNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ExternCrateItem<'a> {
@@ -862,28 +981,31 @@ impl<'a> AstNode<'a> for ExternCrateItem<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ExternCrateItem<'a> {}
+impl<R: TreeRoot<RaTypes>> ExternCrateItemNode<R> {
+    pub fn borrowed(&self) -> ExternCrateItem {
+        ExternCrateItemNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ExternCrateItemNode {
+        ExternCrateItemNode { syntax: self.syntax.owned() }
+    }
+}
 
-// FieldExpr
 
-#[derive(Debug, Clone)]
-pub struct FieldExprNode(SyntaxNode);
+impl<'a> ExternCrateItem<'a> {}
 
-impl FieldExprNode {
-    pub fn ast(&self) -> FieldExpr {
-        FieldExpr::cast(self.0.borrowed()).unwrap()
-    }
+// FieldExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct FieldExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type FieldExpr<'a> = FieldExprNode<RefRoot<'a>>;
 
-impl<'a> From<FieldExpr<'a>> for FieldExprNode {
-    fn from(ast: FieldExpr<'a>) -> FieldExprNode {
-        let syntax = ast.syntax().owned();
-        FieldExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldExprNode<R1>> for FieldExprNode<R2> {
+    fn eq(&self, other: &FieldExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct FieldExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for FieldExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for FieldExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for FieldExpr<'a> {
@@ -896,28 +1018,31 @@ impl<'a> AstNode<'a> for FieldExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> FieldExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> FieldExprNode<R> {
+    pub fn borrowed(&self) -> FieldExpr {
+        FieldExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> FieldExprNode {
+        FieldExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// FieldPatList
 
-#[derive(Debug, Clone)]
-pub struct FieldPatListNode(SyntaxNode);
+impl<'a> FieldExpr<'a> {}
 
-impl FieldPatListNode {
-    pub fn ast(&self) -> FieldPatList {
-        FieldPatList::cast(self.0.borrowed()).unwrap()
-    }
+// FieldPatList
+#[derive(Debug, Clone, Copy,)]
+pub struct FieldPatListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type FieldPatList<'a> = FieldPatListNode<RefRoot<'a>>;
 
-impl<'a> From<FieldPatList<'a>> for FieldPatListNode {
-    fn from(ast: FieldPatList<'a>) -> FieldPatListNode {
-        let syntax = ast.syntax().owned();
-        FieldPatListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldPatListNode<R1>> for FieldPatListNode<R2> {
+    fn eq(&self, other: &FieldPatListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct FieldPatList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for FieldPatListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for FieldPatListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for FieldPatList<'a> {
@@ -930,28 +1055,31 @@ impl<'a> AstNode<'a> for FieldPatList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> FieldPatList<'a> {}
+impl<R: TreeRoot<RaTypes>> FieldPatListNode<R> {
+    pub fn borrowed(&self) -> FieldPatList {
+        FieldPatListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> FieldPatListNode {
+        FieldPatListNode { syntax: self.syntax.owned() }
+    }
+}
 
-// FnDef
 
-#[derive(Debug, Clone)]
-pub struct FnDefNode(SyntaxNode);
+impl<'a> FieldPatList<'a> {}
 
-impl FnDefNode {
-    pub fn ast(&self) -> FnDef {
-        FnDef::cast(self.0.borrowed()).unwrap()
-    }
+// FnDef
+#[derive(Debug, Clone, Copy,)]
+pub struct FnDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type FnDef<'a> = FnDefNode<RefRoot<'a>>;
 
-impl<'a> From<FnDef<'a>> for FnDefNode {
-    fn from(ast: FnDef<'a>) -> FnDefNode {
-        let syntax = ast.syntax().owned();
-        FnDefNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnDefNode<R1>> for FnDefNode<R2> {
+    fn eq(&self, other: &FnDefNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct FnDef<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for FnDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for FnDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for FnDef<'a> {
@@ -964,6 +1092,16 @@ impl<'a> AstNode<'a> for FnDef<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> FnDefNode<R> {
+    pub fn borrowed(&self) -> FnDef {
+        FnDefNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> FnDefNode {
+        FnDefNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for FnDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {}
@@ -983,25 +1121,18 @@ impl<'a> FnDef<'a> {
 }
 
 // FnPointerType
-
-#[derive(Debug, Clone)]
-pub struct FnPointerTypeNode(SyntaxNode);
-
-impl FnPointerTypeNode {
-    pub fn ast(&self) -> FnPointerType {
-        FnPointerType::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct FnPointerTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type FnPointerType<'a> = FnPointerTypeNode<RefRoot<'a>>;
 
-impl<'a> From<FnPointerType<'a>> for FnPointerTypeNode {
-    fn from(ast: FnPointerType<'a>) -> FnPointerTypeNode {
-        let syntax = ast.syntax().owned();
-        FnPointerTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnPointerTypeNode<R1>> for FnPointerTypeNode<R2> {
+    fn eq(&self, other: &FnPointerTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct FnPointerType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for FnPointerTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for FnPointerTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for FnPointerType<'a> {
@@ -1014,28 +1145,31 @@ impl<'a> AstNode<'a> for FnPointerType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> FnPointerType<'a> {}
+impl<R: TreeRoot<RaTypes>> FnPointerTypeNode<R> {
+    pub fn borrowed(&self) -> FnPointerType {
+        FnPointerTypeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> FnPointerTypeNode {
+        FnPointerTypeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// ForExpr
 
-#[derive(Debug, Clone)]
-pub struct ForExprNode(SyntaxNode);
+impl<'a> FnPointerType<'a> {}
 
-impl ForExprNode {
-    pub fn ast(&self) -> ForExpr {
-        ForExpr::cast(self.0.borrowed()).unwrap()
-    }
+// ForExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct ForExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ForExpr<'a> = ForExprNode<RefRoot<'a>>;
 
-impl<'a> From<ForExpr<'a>> for ForExprNode {
-    fn from(ast: ForExpr<'a>) -> ForExprNode {
-        let syntax = ast.syntax().owned();
-        ForExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForExprNode<R1>> for ForExprNode<R2> {
+    fn eq(&self, other: &ForExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ForExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ForExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ForExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ForExpr<'a> {
@@ -1048,6 +1182,16 @@ impl<'a> AstNode<'a> for ForExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ForExprNode<R> {
+    pub fn borrowed(&self) -> ForExpr {
+        ForExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ForExprNode {
+        ForExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::LoopBodyOwner<'a> for ForExpr<'a> {}
 impl<'a> ForExpr<'a> {
     pub fn pat(self) -> Option<Pat<'a>> {
@@ -1060,25 +1204,18 @@ impl<'a> ForExpr<'a> {
 }
 
 // ForType
-
-#[derive(Debug, Clone)]
-pub struct ForTypeNode(SyntaxNode);
-
-impl ForTypeNode {
-    pub fn ast(&self) -> ForType {
-        ForType::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ForTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ForType<'a> = ForTypeNode<RefRoot<'a>>;
 
-impl<'a> From<ForType<'a>> for ForTypeNode {
-    fn from(ast: ForType<'a>) -> ForTypeNode {
-        let syntax = ast.syntax().owned();
-        ForTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForTypeNode<R1>> for ForTypeNode<R2> {
+    fn eq(&self, other: &ForTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ForType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ForTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ForTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ForType<'a> {
@@ -1091,28 +1228,31 @@ impl<'a> AstNode<'a> for ForType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ForType<'a> {}
+impl<R: TreeRoot<RaTypes>> ForTypeNode<R> {
+    pub fn borrowed(&self) -> ForType {
+        ForTypeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ForTypeNode {
+        ForTypeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// IfExpr
 
-#[derive(Debug, Clone)]
-pub struct IfExprNode(SyntaxNode);
+impl<'a> ForType<'a> {}
 
-impl IfExprNode {
-    pub fn ast(&self) -> IfExpr {
-        IfExpr::cast(self.0.borrowed()).unwrap()
-    }
+// IfExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct IfExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type IfExpr<'a> = IfExprNode<RefRoot<'a>>;
 
-impl<'a> From<IfExpr<'a>> for IfExprNode {
-    fn from(ast: IfExpr<'a>) -> IfExprNode {
-        let syntax = ast.syntax().owned();
-        IfExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IfExprNode<R1>> for IfExprNode<R2> {
+    fn eq(&self, other: &IfExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct IfExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for IfExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for IfExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for IfExpr<'a> {
@@ -1125,6 +1265,16 @@ impl<'a> AstNode<'a> for IfExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> IfExprNode<R> {
+    pub fn borrowed(&self) -> IfExpr {
+        IfExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> IfExprNode {
+        IfExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> IfExpr<'a> {
     pub fn condition(self) -> Option<Condition<'a>> {
         super::child_opt(self)
@@ -1132,25 +1282,18 @@ impl<'a> IfExpr<'a> {
 }
 
 // ImplItem
-
-#[derive(Debug, Clone)]
-pub struct ImplItemNode(SyntaxNode);
-
-impl ImplItemNode {
-    pub fn ast(&self) -> ImplItem {
-        ImplItem::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ImplItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ImplItem<'a> = ImplItemNode<RefRoot<'a>>;
 
-impl<'a> From<ImplItem<'a>> for ImplItemNode {
-    fn from(ast: ImplItem<'a>) -> ImplItemNode {
-        let syntax = ast.syntax().owned();
-        ImplItemNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplItemNode<R1>> for ImplItemNode<R2> {
+    fn eq(&self, other: &ImplItemNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ImplItem<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ImplItemNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ImplItemNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ImplItem<'a> {
@@ -1163,28 +1306,31 @@ impl<'a> AstNode<'a> for ImplItem<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ImplItem<'a> {}
+impl<R: TreeRoot<RaTypes>> ImplItemNode<R> {
+    pub fn borrowed(&self) -> ImplItem {
+        ImplItemNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ImplItemNode {
+        ImplItemNode { syntax: self.syntax.owned() }
+    }
+}
 
-// ImplTraitType
 
-#[derive(Debug, Clone)]
-pub struct ImplTraitTypeNode(SyntaxNode);
+impl<'a> ImplItem<'a> {}
 
-impl ImplTraitTypeNode {
-    pub fn ast(&self) -> ImplTraitType {
-        ImplTraitType::cast(self.0.borrowed()).unwrap()
-    }
+// ImplTraitType
+#[derive(Debug, Clone, Copy,)]
+pub struct ImplTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ImplTraitType<'a> = ImplTraitTypeNode<RefRoot<'a>>;
 
-impl<'a> From<ImplTraitType<'a>> for ImplTraitTypeNode {
-    fn from(ast: ImplTraitType<'a>) -> ImplTraitTypeNode {
-        let syntax = ast.syntax().owned();
-        ImplTraitTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplTraitTypeNode<R1>> for ImplTraitTypeNode<R2> {
+    fn eq(&self, other: &ImplTraitTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ImplTraitType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ImplTraitTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ImplTraitTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ImplTraitType<'a> {
@@ -1197,28 +1343,31 @@ impl<'a> AstNode<'a> for ImplTraitType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ImplTraitType<'a> {}
+impl<R: TreeRoot<RaTypes>> ImplTraitTypeNode<R> {
+    pub fn borrowed(&self) -> ImplTraitType {
+        ImplTraitTypeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ImplTraitTypeNode {
+        ImplTraitTypeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// IndexExpr
 
-#[derive(Debug, Clone)]
-pub struct IndexExprNode(SyntaxNode);
+impl<'a> ImplTraitType<'a> {}
 
-impl IndexExprNode {
-    pub fn ast(&self) -> IndexExpr {
-        IndexExpr::cast(self.0.borrowed()).unwrap()
-    }
+// IndexExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct IndexExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type IndexExpr<'a> = IndexExprNode<RefRoot<'a>>;
 
-impl<'a> From<IndexExpr<'a>> for IndexExprNode {
-    fn from(ast: IndexExpr<'a>) -> IndexExprNode {
-        let syntax = ast.syntax().owned();
-        IndexExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IndexExprNode<R1>> for IndexExprNode<R2> {
+    fn eq(&self, other: &IndexExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct IndexExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for IndexExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for IndexExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for IndexExpr<'a> {
@@ -1231,28 +1380,31 @@ impl<'a> AstNode<'a> for IndexExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> IndexExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> IndexExprNode<R> {
+    pub fn borrowed(&self) -> IndexExpr {
+        IndexExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> IndexExprNode {
+        IndexExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// ItemList
 
-#[derive(Debug, Clone)]
-pub struct ItemListNode(SyntaxNode);
+impl<'a> IndexExpr<'a> {}
 
-impl ItemListNode {
-    pub fn ast(&self) -> ItemList {
-        ItemList::cast(self.0.borrowed()).unwrap()
-    }
+// ItemList
+#[derive(Debug, Clone, Copy,)]
+pub struct ItemListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ItemList<'a> = ItemListNode<RefRoot<'a>>;
 
-impl<'a> From<ItemList<'a>> for ItemListNode {
-    fn from(ast: ItemList<'a>) -> ItemListNode {
-        let syntax = ast.syntax().owned();
-        ItemListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ItemListNode<R1>> for ItemListNode<R2> {
+    fn eq(&self, other: &ItemListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ItemList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ItemListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ItemListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ItemList<'a> {
@@ -1265,30 +1417,33 @@ impl<'a> AstNode<'a> for ItemList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ItemListNode<R> {
+    pub fn borrowed(&self) -> ItemList {
+        ItemListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ItemListNode {
+        ItemListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::FnDefOwner<'a> for ItemList<'a> {}
 impl<'a> ast::ModuleItemOwner<'a> for ItemList<'a> {}
 impl<'a> ItemList<'a> {}
 
 // Label
-
-#[derive(Debug, Clone)]
-pub struct LabelNode(SyntaxNode);
-
-impl LabelNode {
-    pub fn ast(&self) -> Label {
-        Label::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct LabelNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Label<'a> = LabelNode<RefRoot<'a>>;
 
-impl<'a> From<Label<'a>> for LabelNode {
-    fn from(ast: Label<'a>) -> LabelNode {
-        let syntax = ast.syntax().owned();
-        LabelNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LabelNode<R1>> for LabelNode<R2> {
+    fn eq(&self, other: &LabelNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Label<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LabelNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LabelNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Label<'a> {
@@ -1301,28 +1456,31 @@ impl<'a> AstNode<'a> for Label<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Label<'a> {}
+impl<R: TreeRoot<RaTypes>> LabelNode<R> {
+    pub fn borrowed(&self) -> Label {
+        LabelNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LabelNode {
+        LabelNode { syntax: self.syntax.owned() }
+    }
+}
 
-// LambdaExpr
 
-#[derive(Debug, Clone)]
-pub struct LambdaExprNode(SyntaxNode);
+impl<'a> Label<'a> {}
 
-impl LambdaExprNode {
-    pub fn ast(&self) -> LambdaExpr {
-        LambdaExpr::cast(self.0.borrowed()).unwrap()
-    }
+// LambdaExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct LambdaExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type LambdaExpr<'a> = LambdaExprNode<RefRoot<'a>>;
 
-impl<'a> From<LambdaExpr<'a>> for LambdaExprNode {
-    fn from(ast: LambdaExpr<'a>) -> LambdaExprNode {
-        let syntax = ast.syntax().owned();
-        LambdaExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LambdaExprNode<R1>> for LambdaExprNode<R2> {
+    fn eq(&self, other: &LambdaExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct LambdaExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LambdaExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LambdaExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for LambdaExpr<'a> {
@@ -1335,6 +1493,16 @@ impl<'a> AstNode<'a> for LambdaExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> LambdaExprNode<R> {
+    pub fn borrowed(&self) -> LambdaExpr {
+        LambdaExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LambdaExprNode {
+        LambdaExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> LambdaExpr<'a> {
     pub fn param_list(self) -> Option<ParamList<'a>> {
         super::child_opt(self)
@@ -1346,25 +1514,18 @@ impl<'a> LambdaExpr<'a> {
 }
 
 // LetStmt
-
-#[derive(Debug, Clone)]
-pub struct LetStmtNode(SyntaxNode);
-
-impl LetStmtNode {
-    pub fn ast(&self) -> LetStmt {
-        LetStmt::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct LetStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type LetStmt<'a> = LetStmtNode<RefRoot<'a>>;
 
-impl<'a> From<LetStmt<'a>> for LetStmtNode {
-    fn from(ast: LetStmt<'a>) -> LetStmtNode {
-        let syntax = ast.syntax().owned();
-        LetStmtNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LetStmtNode<R1>> for LetStmtNode<R2> {
+    fn eq(&self, other: &LetStmtNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct LetStmt<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LetStmtNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LetStmtNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for LetStmt<'a> {
@@ -1377,6 +1538,16 @@ impl<'a> AstNode<'a> for LetStmt<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> LetStmtNode<R> {
+    pub fn borrowed(&self) -> LetStmt {
+        LetStmtNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LetStmtNode {
+        LetStmtNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> LetStmt<'a> {
     pub fn pat(self) -> Option<Pat<'a>> {
         super::child_opt(self)
@@ -1388,25 +1559,18 @@ impl<'a> LetStmt<'a> {
 }
 
 // Lifetime
-
-#[derive(Debug, Clone)]
-pub struct LifetimeNode(SyntaxNode);
-
-impl LifetimeNode {
-    pub fn ast(&self) -> Lifetime {
-        Lifetime::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct LifetimeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Lifetime<'a> = LifetimeNode<RefRoot<'a>>;
 
-impl<'a> From<Lifetime<'a>> for LifetimeNode {
-    fn from(ast: Lifetime<'a>) -> LifetimeNode {
-        let syntax = ast.syntax().owned();
-        LifetimeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeNode<R1>> for LifetimeNode<R2> {
+    fn eq(&self, other: &LifetimeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Lifetime<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LifetimeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LifetimeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Lifetime<'a> {
@@ -1419,28 +1583,31 @@ impl<'a> AstNode<'a> for Lifetime<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Lifetime<'a> {}
+impl<R: TreeRoot<RaTypes>> LifetimeNode<R> {
+    pub fn borrowed(&self) -> Lifetime {
+        LifetimeNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LifetimeNode {
+        LifetimeNode { syntax: self.syntax.owned() }
+    }
+}
 
-// LifetimeParam
 
-#[derive(Debug, Clone)]
-pub struct LifetimeParamNode(SyntaxNode);
+impl<'a> Lifetime<'a> {}
 
-impl LifetimeParamNode {
-    pub fn ast(&self) -> LifetimeParam {
-        LifetimeParam::cast(self.0.borrowed()).unwrap()
-    }
+// LifetimeParam
+#[derive(Debug, Clone, Copy,)]
+pub struct LifetimeParamNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type LifetimeParam<'a> = LifetimeParamNode<RefRoot<'a>>;
 
-impl<'a> From<LifetimeParam<'a>> for LifetimeParamNode {
-    fn from(ast: LifetimeParam<'a>) -> LifetimeParamNode {
-        let syntax = ast.syntax().owned();
-        LifetimeParamNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeParamNode<R1>> for LifetimeParamNode<R2> {
+    fn eq(&self, other: &LifetimeParamNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct LifetimeParam<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LifetimeParamNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LifetimeParamNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for LifetimeParam<'a> {
@@ -1453,6 +1620,16 @@ impl<'a> AstNode<'a> for LifetimeParam<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> LifetimeParamNode<R> {
+    pub fn borrowed(&self) -> LifetimeParam {
+        LifetimeParamNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LifetimeParamNode {
+        LifetimeParamNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> LifetimeParam<'a> {
     pub fn lifetime(self) -> Option<Lifetime<'a>> {
         super::child_opt(self)
@@ -1460,25 +1637,18 @@ impl<'a> LifetimeParam<'a> {
 }
 
 // Literal
-
-#[derive(Debug, Clone)]
-pub struct LiteralNode(SyntaxNode);
-
-impl LiteralNode {
-    pub fn ast(&self) -> Literal {
-        Literal::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct LiteralNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Literal<'a> = LiteralNode<RefRoot<'a>>;
 
-impl<'a> From<Literal<'a>> for LiteralNode {
-    fn from(ast: Literal<'a>) -> LiteralNode {
-        let syntax = ast.syntax().owned();
-        LiteralNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LiteralNode<R1>> for LiteralNode<R2> {
+    fn eq(&self, other: &LiteralNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Literal<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LiteralNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LiteralNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Literal<'a> {
@@ -1491,28 +1661,31 @@ impl<'a> AstNode<'a> for Literal<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Literal<'a> {}
+impl<R: TreeRoot<RaTypes>> LiteralNode<R> {
+    pub fn borrowed(&self) -> Literal {
+        LiteralNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LiteralNode {
+        LiteralNode { syntax: self.syntax.owned() }
+    }
+}
 
-// LoopExpr
 
-#[derive(Debug, Clone)]
-pub struct LoopExprNode(SyntaxNode);
+impl<'a> Literal<'a> {}
 
-impl LoopExprNode {
-    pub fn ast(&self) -> LoopExpr {
-        LoopExpr::cast(self.0.borrowed()).unwrap()
-    }
+// LoopExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct LoopExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type LoopExpr<'a> = LoopExprNode<RefRoot<'a>>;
 
-impl<'a> From<LoopExpr<'a>> for LoopExprNode {
-    fn from(ast: LoopExpr<'a>) -> LoopExprNode {
-        let syntax = ast.syntax().owned();
-        LoopExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LoopExprNode<R1>> for LoopExprNode<R2> {
+    fn eq(&self, other: &LoopExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct LoopExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for LoopExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for LoopExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for LoopExpr<'a> {
@@ -1525,29 +1698,32 @@ impl<'a> AstNode<'a> for LoopExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> LoopExprNode<R> {
+    pub fn borrowed(&self) -> LoopExpr {
+        LoopExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> LoopExprNode {
+        LoopExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::LoopBodyOwner<'a> for LoopExpr<'a> {}
 impl<'a> LoopExpr<'a> {}
 
 // MatchArm
-
-#[derive(Debug, Clone)]
-pub struct MatchArmNode(SyntaxNode);
-
-impl MatchArmNode {
-    pub fn ast(&self) -> MatchArm {
-        MatchArm::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct MatchArmNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type MatchArm<'a> = MatchArmNode<RefRoot<'a>>;
 
-impl<'a> From<MatchArm<'a>> for MatchArmNode {
-    fn from(ast: MatchArm<'a>) -> MatchArmNode {
-        let syntax = ast.syntax().owned();
-        MatchArmNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmNode<R1>> for MatchArmNode<R2> {
+    fn eq(&self, other: &MatchArmNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct MatchArm<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for MatchArmNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MatchArmNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for MatchArm<'a> {
@@ -1560,6 +1736,16 @@ impl<'a> AstNode<'a> for MatchArm<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> MatchArmNode<R> {
+    pub fn borrowed(&self) -> MatchArm {
+        MatchArmNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MatchArmNode {
+        MatchArmNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> MatchArm<'a> {
     pub fn pats(self) -> impl Iterator<Item = Pat<'a>> + 'a {
         super::children(self)
@@ -1575,25 +1761,18 @@ impl<'a> MatchArm<'a> {
 }
 
 // MatchArmList
-
-#[derive(Debug, Clone)]
-pub struct MatchArmListNode(SyntaxNode);
-
-impl MatchArmListNode {
-    pub fn ast(&self) -> MatchArmList {
-        MatchArmList::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct MatchArmListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type MatchArmList<'a> = MatchArmListNode<RefRoot<'a>>;
 
-impl<'a> From<MatchArmList<'a>> for MatchArmListNode {
-    fn from(ast: MatchArmList<'a>) -> MatchArmListNode {
-        let syntax = ast.syntax().owned();
-        MatchArmListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmListNode<R1>> for MatchArmListNode<R2> {
+    fn eq(&self, other: &MatchArmListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct MatchArmList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for MatchArmListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MatchArmListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for MatchArmList<'a> {
@@ -1606,6 +1785,16 @@ impl<'a> AstNode<'a> for MatchArmList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> MatchArmListNode<R> {
+    pub fn borrowed(&self) -> MatchArmList {
+        MatchArmListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MatchArmListNode {
+        MatchArmListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> MatchArmList<'a> {
     pub fn arms(self) -> impl Iterator<Item = MatchArm<'a>> + 'a {
         super::children(self)
@@ -1613,25 +1802,18 @@ impl<'a> MatchArmList<'a> {
 }
 
 // MatchExpr
-
-#[derive(Debug, Clone)]
-pub struct MatchExprNode(SyntaxNode);
-
-impl MatchExprNode {
-    pub fn ast(&self) -> MatchExpr {
-        MatchExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct MatchExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type MatchExpr<'a> = MatchExprNode<RefRoot<'a>>;
 
-impl<'a> From<MatchExpr<'a>> for MatchExprNode {
-    fn from(ast: MatchExpr<'a>) -> MatchExprNode {
-        let syntax = ast.syntax().owned();
-        MatchExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchExprNode<R1>> for MatchExprNode<R2> {
+    fn eq(&self, other: &MatchExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct MatchExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for MatchExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MatchExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for MatchExpr<'a> {
@@ -1644,6 +1826,16 @@ impl<'a> AstNode<'a> for MatchExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> MatchExprNode<R> {
+    pub fn borrowed(&self) -> MatchExpr {
+        MatchExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MatchExprNode {
+        MatchExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> MatchExpr<'a> {
     pub fn expr(self) -> Option<Expr<'a>> {
         super::child_opt(self)
@@ -1655,25 +1847,18 @@ impl<'a> MatchExpr<'a> {
 }
 
 // MatchGuard
-
-#[derive(Debug, Clone)]
-pub struct MatchGuardNode(SyntaxNode);
-
-impl MatchGuardNode {
-    pub fn ast(&self) -> MatchGuard {
-        MatchGuard::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct MatchGuardNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type MatchGuard<'a> = MatchGuardNode<RefRoot<'a>>;
 
-impl<'a> From<MatchGuard<'a>> for MatchGuardNode {
-    fn from(ast: MatchGuard<'a>) -> MatchGuardNode {
-        let syntax = ast.syntax().owned();
-        MatchGuardNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchGuardNode<R1>> for MatchGuardNode<R2> {
+    fn eq(&self, other: &MatchGuardNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct MatchGuard<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for MatchGuardNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MatchGuardNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for MatchGuard<'a> {
@@ -1686,28 +1871,31 @@ impl<'a> AstNode<'a> for MatchGuard<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> MatchGuard<'a> {}
+impl<R: TreeRoot<RaTypes>> MatchGuardNode<R> {
+    pub fn borrowed(&self) -> MatchGuard {
+        MatchGuardNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MatchGuardNode {
+        MatchGuardNode { syntax: self.syntax.owned() }
+    }
+}
 
-// MethodCallExpr
 
-#[derive(Debug, Clone)]
-pub struct MethodCallExprNode(SyntaxNode);
+impl<'a> MatchGuard<'a> {}
 
-impl MethodCallExprNode {
-    pub fn ast(&self) -> MethodCallExpr {
-        MethodCallExpr::cast(self.0.borrowed()).unwrap()
-    }
+// MethodCallExpr
+#[derive(Debug, Clone, Copy,)]
+pub struct MethodCallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type MethodCallExpr<'a> = MethodCallExprNode<RefRoot<'a>>;
 
-impl<'a> From<MethodCallExpr<'a>> for MethodCallExprNode {
-    fn from(ast: MethodCallExpr<'a>) -> MethodCallExprNode {
-        let syntax = ast.syntax().owned();
-        MethodCallExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MethodCallExprNode<R1>> for MethodCallExprNode<R2> {
+    fn eq(&self, other: &MethodCallExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct MethodCallExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for MethodCallExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MethodCallExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for MethodCallExpr<'a> {
@@ -1720,6 +1908,16 @@ impl<'a> AstNode<'a> for MethodCallExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> MethodCallExprNode<R> {
+    pub fn borrowed(&self) -> MethodCallExpr {
+        MethodCallExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MethodCallExprNode {
+        MethodCallExprNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::ArgListOwner<'a> for MethodCallExpr<'a> {}
 impl<'a> MethodCallExpr<'a> {
     pub fn expr(self) -> Option<Expr<'a>> {
@@ -1728,25 +1926,18 @@ impl<'a> MethodCallExpr<'a> {
 }
 
 // Module
-
-#[derive(Debug, Clone)]
-pub struct ModuleNode(SyntaxNode);
-
-impl ModuleNode {
-    pub fn ast(&self) -> Module {
-        Module::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ModuleNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Module<'a> = ModuleNode<RefRoot<'a>>;
 
-impl<'a> From<Module<'a>> for ModuleNode {
-    fn from(ast: Module<'a>) -> ModuleNode {
-        let syntax = ast.syntax().owned();
-        ModuleNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ModuleNode<R1>> for ModuleNode<R2> {
+    fn eq(&self, other: &ModuleNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Module<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ModuleNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ModuleNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Module<'a> {
@@ -1759,8 +1950,19 @@ impl<'a> AstNode<'a> for Module<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ModuleNode<R> {
+    pub fn borrowed(&self) -> Module {
+        ModuleNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ModuleNode {
+        ModuleNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for Module<'a> {}
 impl<'a> ast::AttrsOwner<'a> for Module<'a> {}
+impl<'a> ast::DocCommentsOwner<'a> for Module<'a> {}
 impl<'a> Module<'a> {
     pub fn item_list(self) -> Option<ItemList<'a>> {
         super::child_opt(self)
@@ -1768,23 +1970,7 @@ impl<'a> Module<'a> {
 }
 
 // ModuleItem
-
-#[derive(Debug, Clone)]
-pub struct ModuleItemNode(SyntaxNode);
-
-impl ModuleItemNode {
-    pub fn ast(&self) -> ModuleItem {
-        ModuleItem::cast(self.0.borrowed()).unwrap()
-    }
-}
-
-impl<'a> From<ModuleItem<'a>> for ModuleItemNode {
-    fn from(ast: ModuleItem<'a>) -> ModuleItemNode {
-        let syntax = ast.syntax().owned();
-        ModuleItemNode(syntax)
-    }
-}
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ModuleItem<'a> {
     StructDef(StructDef<'a>),
     EnumDef(EnumDef<'a>),
@@ -1836,25 +2022,18 @@ impl<'a> AstNode<'a> for ModuleItem<'a> {
 impl<'a> ModuleItem<'a> {}
 
 // Name
-
-#[derive(Debug, Clone)]
-pub struct NameNode(SyntaxNode);
-
-impl NameNode {
-    pub fn ast(&self) -> Name {
-        Name::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct NameNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Name<'a> = NameNode<RefRoot<'a>>;
 
-impl<'a> From<Name<'a>> for NameNode {
-    fn from(ast: Name<'a>) -> NameNode {
-        let syntax = ast.syntax().owned();
-        NameNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameNode<R1>> for NameNode<R2> {
+    fn eq(&self, other: &NameNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Name<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NameNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NameNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Name<'a> {
@@ -1867,28 +2046,31 @@ impl<'a> AstNode<'a> for Name<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> Name<'a> {}
+impl<R: TreeRoot<RaTypes>> NameNode<R> {
+    pub fn borrowed(&self) -> Name {
+        NameNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NameNode {
+        NameNode { syntax: self.syntax.owned() }
+    }
+}
 
-// NameRef
 
-#[derive(Debug, Clone)]
-pub struct NameRefNode(SyntaxNode);
+impl<'a> Name<'a> {}
 
-impl NameRefNode {
-    pub fn ast(&self) -> NameRef {
-        NameRef::cast(self.0.borrowed()).unwrap()
-    }
+// NameRef
+#[derive(Debug, Clone, Copy,)]
+pub struct NameRefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type NameRef<'a> = NameRefNode<RefRoot<'a>>;
 
-impl<'a> From<NameRef<'a>> for NameRefNode {
-    fn from(ast: NameRef<'a>) -> NameRefNode {
-        let syntax = ast.syntax().owned();
-        NameRefNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameRefNode<R1>> for NameRefNode<R2> {
+    fn eq(&self, other: &NameRefNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct NameRef<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NameRefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NameRefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for NameRef<'a> {
@@ -1901,28 +2083,31 @@ impl<'a> AstNode<'a> for NameRef<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> NameRef<'a> {}
+impl<R: TreeRoot<RaTypes>> NameRefNode<R> {
+    pub fn borrowed(&self) -> NameRef {
+        NameRefNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NameRefNode {
+        NameRefNode { syntax: self.syntax.owned() }
+    }
+}
 
-// NamedField
 
-#[derive(Debug, Clone)]
-pub struct NamedFieldNode(SyntaxNode);
+impl<'a> NameRef<'a> {}
 
-impl NamedFieldNode {
-    pub fn ast(&self) -> NamedField {
-        NamedField::cast(self.0.borrowed()).unwrap()
-    }
+// NamedField
+#[derive(Debug, Clone, Copy,)]
+pub struct NamedFieldNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type NamedField<'a> = NamedFieldNode<RefRoot<'a>>;
 
-impl<'a> From<NamedField<'a>> for NamedFieldNode {
-    fn from(ast: NamedField<'a>) -> NamedFieldNode {
-        let syntax = ast.syntax().owned();
-        NamedFieldNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldNode<R1>> for NamedFieldNode<R2> {
+    fn eq(&self, other: &NamedFieldNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct NamedField<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NamedFieldNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NamedFieldNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for NamedField<'a> {
@@ -1935,28 +2120,31 @@ impl<'a> AstNode<'a> for NamedField<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> NamedField<'a> {}
+impl<R: TreeRoot<RaTypes>> NamedFieldNode<R> {
+    pub fn borrowed(&self) -> NamedField {
+        NamedFieldNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NamedFieldNode {
+        NamedFieldNode { syntax: self.syntax.owned() }
+    }
+}
 
-// NamedFieldDef
 
-#[derive(Debug, Clone)]
-pub struct NamedFieldDefNode(SyntaxNode);
+impl<'a> NamedField<'a> {}
 
-impl NamedFieldDefNode {
-    pub fn ast(&self) -> NamedFieldDef {
-        NamedFieldDef::cast(self.0.borrowed()).unwrap()
-    }
+// NamedFieldDef
+#[derive(Debug, Clone, Copy,)]
+pub struct NamedFieldDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type NamedFieldDef<'a> = NamedFieldDefNode<RefRoot<'a>>;
 
-impl<'a> From<NamedFieldDef<'a>> for NamedFieldDefNode {
-    fn from(ast: NamedFieldDef<'a>) -> NamedFieldDefNode {
-        let syntax = ast.syntax().owned();
-        NamedFieldDefNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldDefNode<R1>> for NamedFieldDefNode<R2> {
+    fn eq(&self, other: &NamedFieldDefNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct NamedFieldDef<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NamedFieldDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NamedFieldDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for NamedFieldDef<'a> {
@@ -1969,30 +2157,33 @@ impl<'a> AstNode<'a> for NamedFieldDef<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> {
+    pub fn borrowed(&self) -> NamedFieldDef {
+        NamedFieldDefNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NamedFieldDefNode {
+        NamedFieldDefNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> NamedFieldDef<'a> {}
 
 // NamedFieldList
-
-#[derive(Debug, Clone)]
-pub struct NamedFieldListNode(SyntaxNode);
-
-impl NamedFieldListNode {
-    pub fn ast(&self) -> NamedFieldList {
-        NamedFieldList::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct NamedFieldListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type NamedFieldList<'a> = NamedFieldListNode<RefRoot<'a>>;
 
-impl<'a> From<NamedFieldList<'a>> for NamedFieldListNode {
-    fn from(ast: NamedFieldList<'a>) -> NamedFieldListNode {
-        let syntax = ast.syntax().owned();
-        NamedFieldListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldListNode<R1>> for NamedFieldListNode<R2> {
+    fn eq(&self, other: &NamedFieldListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct NamedFieldList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NamedFieldListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NamedFieldListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for NamedFieldList<'a> {
@@ -2005,28 +2196,31 @@ impl<'a> AstNode<'a> for NamedFieldList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> NamedFieldList<'a> {}
+impl<R: TreeRoot<RaTypes>> NamedFieldListNode<R> {
+    pub fn borrowed(&self) -> NamedFieldList {
+        NamedFieldListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NamedFieldListNode {
+        NamedFieldListNode { syntax: self.syntax.owned() }
+    }
+}
 
-// NeverType
 
-#[derive(Debug, Clone)]
-pub struct NeverTypeNode(SyntaxNode);
+impl<'a> NamedFieldList<'a> {}
 
-impl NeverTypeNode {
-    pub fn ast(&self) -> NeverType {
-        NeverType::cast(self.0.borrowed()).unwrap()
-    }
+// NeverType
+#[derive(Debug, Clone, Copy,)]
+pub struct NeverTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type NeverType<'a> = NeverTypeNode<RefRoot<'a>>;
 
-impl<'a> From<NeverType<'a>> for NeverTypeNode {
-    fn from(ast: NeverType<'a>) -> NeverTypeNode {
-        let syntax = ast.syntax().owned();
-        NeverTypeNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NeverTypeNode<R1>> for NeverTypeNode<R2> {
+    fn eq(&self, other: &NeverTypeNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct NeverType<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for NeverTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NeverTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for NeverType<'a> {
@@ -2039,26 +2233,20 @@ impl<'a> AstNode<'a> for NeverType<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> NeverType<'a> {}
-
-// NominalDef
-
-#[derive(Debug, Clone)]
-pub struct NominalDefNode(SyntaxNode);
-
-impl NominalDefNode {
-    pub fn ast(&self) -> NominalDef {
-        NominalDef::cast(self.0.borrowed()).unwrap()
+impl<R: TreeRoot<RaTypes>> NeverTypeNode<R> {
+    pub fn borrowed(&self) -> NeverType {
+        NeverTypeNode { syntax: self.syntax.borrowed() }
     }
-}
-
-impl<'a> From<NominalDef<'a>> for NominalDefNode {
-    fn from(ast: NominalDef<'a>) -> NominalDefNode {
-        let syntax = ast.syntax().owned();
-        NominalDefNode(syntax)
+    pub fn owned(&self) -> NeverTypeNode {
+        NeverTypeNode { syntax: self.syntax.owned() }
     }
 }
-#[derive(Debug, Clone, Copy)]
+
+
+impl<'a> NeverType<'a> {}
+
+// NominalDef
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum NominalDef<'a> {
     StructDef(StructDef<'a>),
     EnumDef(EnumDef<'a>),
@@ -2086,25 +2274,18 @@ impl<'a> ast::AttrsOwner<'a> for NominalDef<'a> {}
 impl<'a> NominalDef<'a> {}
 
 // Param
-
-#[derive(Debug, Clone)]
-pub struct ParamNode(SyntaxNode);
-
-impl ParamNode {
-    pub fn ast(&self) -> Param {
-        Param::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ParamNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type Param<'a> = ParamNode<RefRoot<'a>>;
 
-impl<'a> From<Param<'a>> for ParamNode {
-    fn from(ast: Param<'a>) -> ParamNode {
-        let syntax = ast.syntax().owned();
-        ParamNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamNode<R1>> for ParamNode<R2> {
+    fn eq(&self, other: &ParamNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct Param<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ParamNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ParamNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for Param<'a> {
@@ -2117,6 +2298,16 @@ impl<'a> AstNode<'a> for Param<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ParamNode<R> {
+    pub fn borrowed(&self) -> Param {
+        ParamNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ParamNode {
+        ParamNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> Param<'a> {
     pub fn pat(self) -> Option<Pat<'a>> {
         super::child_opt(self)
@@ -2124,25 +2315,18 @@ impl<'a> Param<'a> {
 }
 
 // ParamList
-
-#[derive(Debug, Clone)]
-pub struct ParamListNode(SyntaxNode);
-
-impl ParamListNode {
-    pub fn ast(&self) -> ParamList {
-        ParamList::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ParamListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ParamList<'a> = ParamListNode<RefRoot<'a>>;
 
-impl<'a> From<ParamList<'a>> for ParamListNode {
-    fn from(ast: ParamList<'a>) -> ParamListNode {
-        let syntax = ast.syntax().owned();
-        ParamListNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamListNode<R1>> for ParamListNode<R2> {
+    fn eq(&self, other: &ParamListNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ParamList<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ParamListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ParamListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ParamList<'a> {
@@ -2155,6 +2339,16 @@ impl<'a> AstNode<'a> for ParamList<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
+impl<R: TreeRoot<RaTypes>> ParamListNode<R> {
+    pub fn borrowed(&self) -> ParamList {
+        ParamListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ParamListNode {
+        ParamListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
 impl<'a> ParamList<'a> {
     pub fn params(self) -> impl Iterator<Item = Param<'a>> + 'a {
         super::children(self)
@@ -2166,25 +2360,18 @@ impl<'a> ParamList<'a> {
 }
 
 // ParenExpr
-
-#[derive(Debug, Clone)]
-pub struct ParenExprNode(SyntaxNode);
-
-impl ParenExprNode {
-    pub fn ast(&self) -> ParenExpr {
-        ParenExpr::cast(self.0.borrowed()).unwrap()
-    }
+#[derive(Debug, Clone, Copy,)]
+pub struct ParenExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
 }
+pub type ParenExpr<'a> = ParenExprNode<RefRoot<'a>>;
 
-impl<'a> From<ParenExpr<'a>> for ParenExprNode {
-    fn from(ast: ParenExpr<'a>) -> ParenExprNode {
-        let syntax = ast.syntax().owned();
-        ParenExprNode(syntax)
-    }
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParenExprNode<R1>> for ParenExprNode<R2> {
+    fn eq(&self, other: &ParenExprNode<R1>) -> bool { self.syntax == other.syntax }
 }
-#[derive(Debug, Clone, Copy)]
-pub struct ParenExpr<'a> {
-    syntax: SyntaxNodeRef<'a>,
+impl<R: TreeRoot<RaTypes>> Eq for ParenExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ParenExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
 
 impl<'a> AstNode<'a> for ParenExpr<'a> {
@@ -2197,28 +2384,31 @@ impl<'a> AstNode<'a> for ParenExpr<'a> {
     fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
 
-impl<'a> ParenExpr<'a> {}
+impl<R: TreeRoot<RaTypes>> ParenExprNode<R> {
+    pub fn borrowed(&self) -> ParenExpr {
+        ParenExprNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ParenExprNode {
+        ParenExprNode { syntax: self.syntax.owned() }
+    }
+}
 
-// ParenType
 
-#[derive(Debug, Clone)]
-pub struct ParenTypeNode(SyntaxNode);
+impl<'a> ParenExpr<'a> {}
 
-impl ParenTypeNode {
-    pub fn ast(&self) -> ParenType {
-        ParenType::cast(self.0.borrowed()).unwrap()
-    }
+// ParenType
+#[derive(Debug, Clone, Copy,)]
+pub struct ParenTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,