aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_analysis/src/descriptors/function/imp.rs4
-rw-r--r--crates/ra_analysis/src/descriptors/module/imp.rs8
-rw-r--r--crates/ra_analysis/src/descriptors/module/mod.rs10
-rw-r--r--crates/ra_analysis/src/imp.rs2
-rw-r--r--crates/ra_syntax/Cargo.toml2
-rw-r--r--crates/ra_syntax/src/algo/mod.rs113
-rw-r--r--crates/ra_syntax/src/ast/generated.rs3407
-rw-r--r--crates/ra_syntax/src/ast/generated.rs.tera52
-rw-r--r--crates/ra_syntax/src/ast/mod.rs4
-rw-r--r--crates/ra_syntax/src/grammar/type_params.rs6
-rw-r--r--crates/ra_syntax/src/lib.rs15
-rw-r--r--crates/ra_syntax/src/validation.rs2
-rw-r--r--crates/ra_syntax/src/yellow/mod.rs2
-rw-r--r--crates/ra_syntax/tests/data/parser/err/0027_incomplere_where_for.rs3
-rw-r--r--crates/ra_syntax/tests/data/parser/err/0027_incomplere_where_for.txt27
15 files changed, 1902 insertions, 1755 deletions
diff --git a/crates/ra_analysis/src/descriptors/function/imp.rs b/crates/ra_analysis/src/descriptors/function/imp.rs
index 755e05819..a989a04cd 100644
--- a/crates/ra_analysis/src/descriptors/function/imp.rs
+++ b/crates/ra_analysis/src/descriptors/function/imp.rs
@@ -11,11 +11,11 @@ use crate::descriptors::{
11/// TODO: this should return something more type-safe then `SyntaxNode` 11/// TODO: this should return something more type-safe then `SyntaxNode`
12pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode { 12pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode {
13 let syntax = db.resolve_syntax_ptr(fn_id.0); 13 let syntax = db.resolve_syntax_ptr(fn_id.0);
14 FnDef::cast(syntax.borrowed()).unwrap().into() 14 FnDef::cast(syntax.borrowed()).unwrap().owned()
15} 15}
16 16
17pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> { 17pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> {
18 let syntax = db.fn_syntax(fn_id); 18 let syntax = db.fn_syntax(fn_id);
19 let res = FnScopes::new(syntax.ast()); 19 let res = FnScopes::new(syntax.borrowed());
20 Arc::new(res) 20 Arc::new(res)
21} 21}
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs
index b3b1f1f21..b5c232ea4 100644
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ b/crates/ra_analysis/src/descriptors/module/imp.rs
@@ -41,9 +41,9 @@ pub(crate) fn submodules(
41 db::check_canceled(db)?; 41 db::check_canceled(db)?;
42 let file_id = source.file_id(); 42 let file_id = source.file_id();
43 let submodules = match source.resolve(db) { 43 let submodules = match source.resolve(db) {
44 ModuleSourceNode::Root(it) => collect_submodules(file_id, it.ast()), 44 ModuleSourceNode::Root(it) => collect_submodules(file_id, it.borrowed()),
45 ModuleSourceNode::Inline(it) => it 45 ModuleSourceNode::Inline(it) => it
46 .ast() 46 .borrowed()
47 .item_list() 47 .item_list()
48 .map(|it| collect_submodules(file_id, it)) 48 .map(|it| collect_submodules(file_id, it))
49 .unwrap_or_else(Vec::new), 49 .unwrap_or_else(Vec::new),
@@ -89,8 +89,8 @@ pub(crate) fn module_scope(
89 let tree = db.module_tree(source_root_id)?; 89 let tree = db.module_tree(source_root_id)?;
90 let source = module_id.source(&tree).resolve(db); 90 let source = module_id.source(&tree).resolve(db);
91 let res = match source { 91 let res = match source {
92 ModuleSourceNode::Root(root) => ModuleScope::new(root.ast().items()), 92 ModuleSourceNode::Root(root) => ModuleScope::new(root.borrowed().items()),
93 ModuleSourceNode::Inline(inline) => match inline.ast().item_list() { 93 ModuleSourceNode::Inline(inline) => match inline.borrowed().item_list() {
94 Some(items) => ModuleScope::new(items.items()), 94 Some(items) => ModuleScope::new(items.items()),
95 None => ModuleScope::new(std::iter::empty()), 95 None => ModuleScope::new(std::iter::empty()),
96 }, 96 },
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
index 3d799ba05..03330240d 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -117,7 +117,7 @@ impl ModuleId {
117 .filter_map(|&it| { 117 .filter_map(|&it| {
118 let p = tree.link(it).problem.clone()?; 118 let p = tree.link(it).problem.clone()?;
119 let s = it.bind_source(tree, db); 119 let s = it.bind_source(tree, db);
120 let s = s.ast().name().unwrap().syntax().owned(); 120 let s = s.borrowed().name().unwrap().syntax().owned();
121 Some((s, p)) 121 Some((s, p))
122 }) 122 })
123 .collect() 123 .collect()
@@ -136,11 +136,11 @@ impl LinkId {
136 let owner = self.owner(tree); 136 let owner = self.owner(tree);
137 match owner.source(tree).resolve(db) { 137 match owner.source(tree).resolve(db) {
138 ModuleSourceNode::Root(root) => { 138 ModuleSourceNode::Root(root) => {
139 let ast = imp::modules(root.ast()) 139 let ast = imp::modules(root.borrowed())
140 .find(|(name, _)| name == &tree.link(self).name) 140 .find(|(name, _)| name == &tree.link(self).name)
141 .unwrap() 141 .unwrap()
142 .1; 142 .1;
143 ast.into() 143 ast.owned()
144 } 144 }
145 ModuleSourceNode::Inline(it) => it, 145 ModuleSourceNode::Inline(it) => it,
146 } 146 }
@@ -179,13 +179,13 @@ impl ModuleSource {
179 match self { 179 match self {
180 ModuleSource::File(file_id) => { 180 ModuleSource::File(file_id) => {
181 let syntax = db.file_syntax(file_id); 181 let syntax = db.file_syntax(file_id);
182 ModuleSourceNode::Root(syntax.ast().into()) 182 ModuleSourceNode::Root(syntax.ast().owned())
183 } 183 }
184 ModuleSource::Inline(ptr) => { 184 ModuleSource::Inline(ptr) => {
185 let syntax = db.resolve_syntax_ptr(ptr); 185 let syntax = db.resolve_syntax_ptr(ptr);
186 let syntax = syntax.borrowed(); 186 let syntax = syntax.borrowed();
187 let module = ast::Module::cast(syntax).unwrap(); 187 let module = ast::Module::cast(syntax).unwrap();
188 ModuleSourceNode::Inline(module.into()) 188 ModuleSourceNode::Inline(module.owned())
189 } 189 }
190 } 190 }
191 } 191 }
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index f2482559f..819827b95 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -236,7 +236,7 @@ impl AnalysisImpl {
236 let link = module_id.parent_link(&module_tree)?; 236 let link = module_id.parent_link(&module_tree)?;
237 let file_id = link.owner(&module_tree).source(&module_tree).file_id(); 237 let file_id = link.owner(&module_tree).source(&module_tree).file_id();
238 let decl = link.bind_source(&module_tree, &*self.db); 238 let decl = link.bind_source(&module_tree, &*self.db);
239 let decl = decl.ast(); 239 let decl = decl.borrowed();
240 240
241 let decl_name = decl.name().unwrap(); 241 let decl_name = decl.name().unwrap();
242 242
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 0f709026f..54ee72386 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -13,7 +13,7 @@ unicode-xid = "0.1.0"
13itertools = "0.7.8" 13itertools = "0.7.8"
14drop_bomb = "0.1.4" 14drop_bomb = "0.1.4"
15parking_lot = "0.6.0" 15parking_lot = "0.6.0"
16rowan = "0.1.1" 16rowan = "0.1.2"
17text_unit = "0.1.5" 17text_unit = "0.1.5"
18 18
19[dev-dependencies] 19[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 @@
1pub mod visit; 1pub mod visit;
2// pub mod walk;
3 2
4use crate::{text_utils::contains_offset_nonstrict, SyntaxNodeRef, TextRange, TextUnit}; 3use crate::{SyntaxNode, SyntaxNodeRef, TextRange, TextUnit};
5 4
6pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset { 5pub use rowan::LeafAtOffset;
7 let range = node.range();
8 assert!(
9 contains_offset_nonstrict(range, offset),
10 "Bad offset: range {:?} offset {:?}",
11 range,
12 offset
13 );
14 if range.is_empty() {
15 return LeafAtOffset::None;
16 }
17
18 if node.is_leaf() {
19 return LeafAtOffset::Single(node);
20 }
21
22 let mut children = node.children().filter(|child| {
23 let child_range = child.range();
24 !child_range.is_empty() && contains_offset_nonstrict(child_range, offset)
25 });
26
27 let left = children.next().unwrap();
28 let right = children.next();
29 assert!(children.next().is_none());
30
31 if let Some(right) = right {
32 match (
33 find_leaf_at_offset(left, offset),
34 find_leaf_at_offset(right, offset),
35 ) {
36 (LeafAtOffset::Single(left), LeafAtOffset::Single(right)) => {
37 LeafAtOffset::Between(left, right)
38 }
39 _ => unreachable!(),
40 }
41 } else {
42 find_leaf_at_offset(left, offset)
43 }
44}
45
46#[derive(Clone, Debug)]
47pub enum LeafAtOffset<'a> {
48 None,
49 Single(SyntaxNodeRef<'a>),
50 Between(SyntaxNodeRef<'a>, SyntaxNodeRef<'a>),
51}
52 6
53impl<'a> LeafAtOffset<'a> { 7pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset<SyntaxNodeRef> {
54 pub fn right_biased(self) -> Option<SyntaxNodeRef<'a>> { 8 match node.0.leaf_at_offset(offset) {
55 match self { 9 LeafAtOffset::None => LeafAtOffset::None,
56 LeafAtOffset::None => None, 10 LeafAtOffset::Single(n) => LeafAtOffset::Single(SyntaxNode(n)),
57 LeafAtOffset::Single(node) => Some(node), 11 LeafAtOffset::Between(l, r) => LeafAtOffset::Between(SyntaxNode(l), SyntaxNode(r)),
58 LeafAtOffset::Between(_, right) => Some(right),
59 }
60 }
61
62 pub fn left_biased(self) -> Option<SyntaxNodeRef<'a>> {
63 match self {
64 LeafAtOffset::None => None,
65 LeafAtOffset::Single(node) => Some(node),
66 LeafAtOffset::Between(left, _) => Some(left),
67 }
68 }
69}
70
71impl<'f> Iterator for LeafAtOffset<'f> {
72 type Item = SyntaxNodeRef<'f>;
73
74 fn next(&mut self) -> Option<SyntaxNodeRef<'f>> {
75 match *self {
76 LeafAtOffset::None => None,
77 LeafAtOffset::Single(node) => {
78 *self = LeafAtOffset::None;
79 Some(node)
80 }
81 LeafAtOffset::Between(left, right) => {
82 *self = LeafAtOffset::Single(right);
83 Some(left)
84 }
85 }
86 } 12 }
87} 13}
88 14
89pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef { 15pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
90 assert!( 16 SyntaxNode(root.0.covering_node(range))
91 range.is_subrange(&root.range()),
92 "node range: {:?}, target range: {:?}",
93 root.range(),
94 range,
95 );
96 let (left, right) = match (
97 find_leaf_at_offset(root, range.start()).right_biased(),
98 find_leaf_at_offset(root, range.end()).left_biased(),
99 ) {
100 (Some(l), Some(r)) => (l, r),
101 _ => return root,
102 };
103
104 common_ancestor(left, right)
105}
106
107fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
108 for p in n1.ancestors() {
109 if n2.ancestors().any(|a| a == p) {
110 return p;
111 }
112 }
113 panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
114} 17}
115 18
116pub fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item = T> { 19pub 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..3878c99a8 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,34 +1,36 @@
1// This file is automatically generated based on the file `./generated.rs.tera` when `cargo gen-syntax` is run 1// This file is automatically generated based on the file `./generated.rs.tera` when `cargo gen-syntax` is run
2// Do not edit manually 2// Do not edit manually
3 3
4//! This module contains auto-generated Rust AST. Like `SyntaxNode`s, AST nodes
5//! are generic over ownership: `X<'a>` things are `Copy` references, `XNode`
6//! are Arc-based. You can switch between the two variants using `.owned` and
7//! `.borrowed` functions. Most of the code works with borowed mode, and only
8//! this mode has all AST accessors.
9
4#![cfg_attr(rustfmt, rustfmt_skip)] 10#![cfg_attr(rustfmt, rustfmt_skip)]
5 11
12use std::hash::{Hash, Hasher};
13
6use crate::{ 14use crate::{
7 ast, 15 ast,
8 SyntaxNode, SyntaxNodeRef, AstNode, 16 SyntaxNode, SyntaxNodeRef, AstNode,
17 yellow::{TreeRoot, RaTypes, OwnedRoot, RefRoot},
9 SyntaxKind::*, 18 SyntaxKind::*,
10}; 19};
11 20
12// ArgList 21// ArgList
13 22#[derive(Debug, Clone, Copy,)]
14#[derive(Debug, Clone)] 23pub struct ArgListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
15pub struct ArgListNode(SyntaxNode); 24 pub(crate) syntax: SyntaxNode<R>,
16
17impl ArgListNode {
18 pub fn ast(&self) -> ArgList {
19 ArgList::cast(self.0.borrowed()).unwrap()
20 }
21} 25}
26pub type ArgList<'a> = ArgListNode<RefRoot<'a>>;
22 27
23impl<'a> From<ArgList<'a>> for ArgListNode { 28impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArgListNode<R1>> for ArgListNode<R2> {
24 fn from(ast: ArgList<'a>) -> ArgListNode { 29 fn eq(&self, other: &ArgListNode<R1>) -> bool { self.syntax == other.syntax }
25 let syntax = ast.syntax().owned();
26 ArgListNode(syntax)
27 }
28} 30}
29#[derive(Debug, Clone, Copy)] 31impl<R: TreeRoot<RaTypes>> Eq for ArgListNode<R> {}
30pub struct ArgList<'a> { 32impl<R: TreeRoot<RaTypes>> Hash for ArgListNode<R> {
31 syntax: SyntaxNodeRef<'a>, 33 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
32} 34}
33 35
34impl<'a> AstNode<'a> for ArgList<'a> { 36impl<'a> AstNode<'a> for ArgList<'a> {
@@ -41,6 +43,16 @@ impl<'a> AstNode<'a> for ArgList<'a> {
41 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 43 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
42} 44}
43 45
46impl<R: TreeRoot<RaTypes>> ArgListNode<R> {
47 pub fn borrowed(&self) -> ArgList {
48 ArgListNode { syntax: self.syntax.borrowed() }
49 }
50 pub fn owned(&self) -> ArgListNode {
51 ArgListNode { syntax: self.syntax.owned() }
52 }
53}
54
55
44impl<'a> ArgList<'a> { 56impl<'a> ArgList<'a> {
45 pub fn args(self) -> impl Iterator<Item = Expr<'a>> + 'a { 57 pub fn args(self) -> impl Iterator<Item = Expr<'a>> + 'a {
46 super::children(self) 58 super::children(self)
@@ -48,25 +60,18 @@ impl<'a> ArgList<'a> {
48} 60}
49 61
50// ArrayExpr 62// ArrayExpr
51 63#[derive(Debug, Clone, Copy,)]
52#[derive(Debug, Clone)] 64pub struct ArrayExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
53pub struct ArrayExprNode(SyntaxNode); 65 pub(crate) syntax: SyntaxNode<R>,
54
55impl ArrayExprNode {
56 pub fn ast(&self) -> ArrayExpr {
57 ArrayExpr::cast(self.0.borrowed()).unwrap()
58 }
59} 66}
67pub type ArrayExpr<'a> = ArrayExprNode<RefRoot<'a>>;
60 68
61impl<'a> From<ArrayExpr<'a>> for ArrayExprNode { 69impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayExprNode<R1>> for ArrayExprNode<R2> {
62 fn from(ast: ArrayExpr<'a>) -> ArrayExprNode { 70 fn eq(&self, other: &ArrayExprNode<R1>) -> bool { self.syntax == other.syntax }
63 let syntax = ast.syntax().owned();
64 ArrayExprNode(syntax)
65 }
66} 71}
67#[derive(Debug, Clone, Copy)] 72impl<R: TreeRoot<RaTypes>> Eq for ArrayExprNode<R> {}
68pub struct ArrayExpr<'a> { 73impl<R: TreeRoot<RaTypes>> Hash for ArrayExprNode<R> {
69 syntax: SyntaxNodeRef<'a>, 74 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
70} 75}
71 76
72impl<'a> AstNode<'a> for ArrayExpr<'a> { 77impl<'a> AstNode<'a> for ArrayExpr<'a> {
@@ -79,28 +84,31 @@ impl<'a> AstNode<'a> for ArrayExpr<'a> {
79 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 84 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
80} 85}
81 86
82impl<'a> ArrayExpr<'a> {} 87impl<R: TreeRoot<RaTypes>> ArrayExprNode<R> {
88 pub fn borrowed(&self) -> ArrayExpr {
89 ArrayExprNode { syntax: self.syntax.borrowed() }
90 }
91 pub fn owned(&self) -> ArrayExprNode {
92 ArrayExprNode { syntax: self.syntax.owned() }
93 }
94}
83 95
84// ArrayType
85 96
86#[derive(Debug, Clone)] 97impl<'a> ArrayExpr<'a> {}
87pub struct ArrayTypeNode(SyntaxNode);
88 98
89impl ArrayTypeNode { 99// ArrayType
90 pub fn ast(&self) -> ArrayType { 100#[derive(Debug, Clone, Copy,)]
91 ArrayType::cast(self.0.borrowed()).unwrap() 101pub struct ArrayTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
92 } 102 pub(crate) syntax: SyntaxNode<R>,
93} 103}
104pub type ArrayType<'a> = ArrayTypeNode<RefRoot<'a>>;
94 105
95impl<'a> From<ArrayType<'a>> for ArrayTypeNode { 106impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayTypeNode<R1>> for ArrayTypeNode<R2> {
96 fn from(ast: ArrayType<'a>) -> ArrayTypeNode { 107 fn eq(&self, other: &ArrayTypeNode<R1>) -> bool { self.syntax == other.syntax }
97 let syntax = ast.syntax().owned();
98 ArrayTypeNode(syntax)
99 }
100} 108}
101#[derive(Debug, Clone, Copy)] 109impl<R: TreeRoot<RaTypes>> Eq for ArrayTypeNode<R> {}
102pub struct ArrayType<'a> { 110impl<R: TreeRoot<RaTypes>> Hash for ArrayTypeNode<R> {
103 syntax: SyntaxNodeRef<'a>, 111 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
104} 112}
105 113
106impl<'a> AstNode<'a> for ArrayType<'a> { 114impl<'a> AstNode<'a> for ArrayType<'a> {
@@ -113,28 +121,31 @@ impl<'a> AstNode<'a> for ArrayType<'a> {
113 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 121 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
114} 122}
115 123
116impl<'a> ArrayType<'a> {} 124impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> {
125 pub fn borrowed(&self) -> ArrayType {
126 ArrayTypeNode { syntax: self.syntax.borrowed() }
127 }
128 pub fn owned(&self) -> ArrayTypeNode {
129 ArrayTypeNode { syntax: self.syntax.owned() }
130 }
131}
117 132
118// Attr
119 133
120#[derive(Debug, Clone)] 134impl<'a> ArrayType<'a> {}
121pub struct AttrNode(SyntaxNode);
122 135
123impl AttrNode { 136// Attr
124 pub fn ast(&self) -> Attr { 137#[derive(Debug, Clone, Copy,)]
125 Attr::cast(self.0.borrowed()).unwrap() 138pub struct AttrNode<R: TreeRoot<RaTypes> = OwnedRoot> {
126 } 139 pub(crate) syntax: SyntaxNode<R>,
127} 140}
141pub type Attr<'a> = AttrNode<RefRoot<'a>>;
128 142
129impl<'a> From<Attr<'a>> for AttrNode { 143impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<AttrNode<R1>> for AttrNode<R2> {
130 fn from(ast: Attr<'a>) -> AttrNode { 144 fn eq(&self, other: &AttrNode<R1>) -> bool { self.syntax == other.syntax }
131 let syntax = ast.syntax().owned();
132 AttrNode(syntax)
133 }
134} 145}
135#[derive(Debug, Clone, Copy)] 146impl<R: TreeRoot<RaTypes>> Eq for AttrNode<R> {}
136pub struct Attr<'a> { 147impl<R: TreeRoot<RaTypes>> Hash for AttrNode<R> {
137 syntax: SyntaxNodeRef<'a>, 148 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
138} 149}
139 150
140impl<'a> AstNode<'a> for Attr<'a> { 151impl<'a> AstNode<'a> for Attr<'a> {
@@ -147,6 +158,16 @@ impl<'a> AstNode<'a> for Attr<'a> {
147 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 158 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
148} 159}
149 160
161impl<R: TreeRoot<RaTypes>> AttrNode<R> {
162 pub fn borrowed(&self) -> Attr {
163 AttrNode { syntax: self.syntax.borrowed() }
164 }
165 pub fn owned(&self) -> AttrNode {
166 AttrNode { syntax: self.syntax.owned() }
167 }
168}
169
170
150impl<'a> Attr<'a> { 171impl<'a> Attr<'a> {
151 pub fn value(self) -> Option<TokenTree<'a>> { 172 pub fn value(self) -> Option<TokenTree<'a>> {
152 super::child_opt(self) 173 super::child_opt(self)
@@ -154,25 +175,18 @@ impl<'a> Attr<'a> {
154} 175}
155 176
156// BinExpr 177// BinExpr
157 178#[derive(Debug, Clone, Copy,)]
158#[derive(Debug, Clone)] 179pub struct BinExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
159pub struct BinExprNode(SyntaxNode); 180 pub(crate) syntax: SyntaxNode<R>,
160
161impl BinExprNode {
162 pub fn ast(&self) -> BinExpr {
163 BinExpr::cast(self.0.borrowed()).unwrap()
164 }
165} 181}
182pub type BinExpr<'a> = BinExprNode<RefRoot<'a>>;
166 183
167impl<'a> From<BinExpr<'a>> for BinExprNode { 184impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BinExprNode<R1>> for BinExprNode<R2> {
168 fn from(ast: BinExpr<'a>) -> BinExprNode { 185 fn eq(&self, other: &BinExprNode<R1>) -> bool { self.syntax == other.syntax }
169 let syntax = ast.syntax().owned();
170 BinExprNode(syntax)
171 }
172} 186}
173#[derive(Debug, Clone, Copy)] 187impl<R: TreeRoot<RaTypes>> Eq for BinExprNode<R> {}
174pub struct BinExpr<'a> { 188impl<R: TreeRoot<RaTypes>> Hash for BinExprNode<R> {
175 syntax: SyntaxNodeRef<'a>, 189 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
176} 190}
177 191
178impl<'a> AstNode<'a> for BinExpr<'a> { 192impl<'a> AstNode<'a> for BinExpr<'a> {
@@ -185,28 +199,31 @@ impl<'a> AstNode<'a> for BinExpr<'a> {
185 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 199 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
186} 200}
187 201
188impl<'a> BinExpr<'a> {} 202impl<R: TreeRoot<RaTypes>> BinExprNode<R> {
203 pub fn borrowed(&self) -> BinExpr {
204 BinExprNode { syntax: self.syntax.borrowed() }
205 }
206 pub fn owned(&self) -> BinExprNode {
207 BinExprNode { syntax: self.syntax.owned() }
208 }
209}
189 210
190// BindPat
191 211
192#[derive(Debug, Clone)] 212impl<'a> BinExpr<'a> {}
193pub struct BindPatNode(SyntaxNode);
194 213
195impl BindPatNode { 214// BindPat
196 pub fn ast(&self) -> BindPat { 215#[derive(Debug, Clone, Copy,)]
197 BindPat::cast(self.0.borrowed()).unwrap() 216pub struct BindPatNode<R: TreeRoot<RaTypes> = OwnedRoot> {
198 } 217 pub(crate) syntax: SyntaxNode<R>,
199} 218}
219pub type BindPat<'a> = BindPatNode<RefRoot<'a>>;
200 220
201impl<'a> From<BindPat<'a>> for BindPatNode { 221impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BindPatNode<R1>> for BindPatNode<R2> {
202 fn from(ast: BindPat<'a>) -> BindPatNode { 222 fn eq(&self, other: &BindPatNode<R1>) -> bool { self.syntax == other.syntax }
203 let syntax = ast.syntax().owned();
204 BindPatNode(syntax)
205 }
206} 223}
207#[derive(Debug, Clone, Copy)] 224impl<R: TreeRoot<RaTypes>> Eq for BindPatNode<R> {}
208pub struct BindPat<'a> { 225impl<R: TreeRoot<RaTypes>> Hash for BindPatNode<R> {
209 syntax: SyntaxNodeRef<'a>, 226 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
210} 227}
211 228
212impl<'a> AstNode<'a> for BindPat<'a> { 229impl<'a> AstNode<'a> for BindPat<'a> {
@@ -219,29 +236,32 @@ impl<'a> AstNode<'a> for BindPat<'a> {
219 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 236 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
220} 237}
221 238
239impl<R: TreeRoot<RaTypes>> BindPatNode<R> {
240 pub fn borrowed(&self) -> BindPat {
241 BindPatNode { syntax: self.syntax.borrowed() }
242 }
243 pub fn owned(&self) -> BindPatNode {
244 BindPatNode { syntax: self.syntax.owned() }
245 }
246}
247
248
222impl<'a> ast::NameOwner<'a> for BindPat<'a> {} 249impl<'a> ast::NameOwner<'a> for BindPat<'a> {}
223impl<'a> BindPat<'a> {} 250impl<'a> BindPat<'a> {}
224 251
225// Block 252// Block
226 253#[derive(Debug, Clone, Copy,)]
227#[derive(Debug, Clone)] 254pub struct BlockNode<R: TreeRoot<RaTypes> = OwnedRoot> {
228pub struct BlockNode(SyntaxNode); 255 pub(crate) syntax: SyntaxNode<R>,
229
230impl BlockNode {
231 pub fn ast(&self) -> Block {
232 Block::cast(self.0.borrowed()).unwrap()
233 }
234} 256}
257pub type Block<'a> = BlockNode<RefRoot<'a>>;
235 258
236impl<'a> From<Block<'a>> for BlockNode { 259impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockNode<R1>> for BlockNode<R2> {
237 fn from(ast: Block<'a>) -> BlockNode { 260 fn eq(&self, other: &BlockNode<R1>) -> bool { self.syntax == other.syntax }
238 let syntax = ast.syntax().owned();
239 BlockNode(syntax)
240 }
241} 261}
242#[derive(Debug, Clone, Copy)] 262impl<R: TreeRoot<RaTypes>> Eq for BlockNode<R> {}
243pub struct Block<'a> { 263impl<R: TreeRoot<RaTypes>> Hash for BlockNode<R> {
244 syntax: SyntaxNodeRef<'a>, 264 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
245} 265}
246 266
247impl<'a> AstNode<'a> for Block<'a> { 267impl<'a> AstNode<'a> for Block<'a> {
@@ -254,6 +274,16 @@ impl<'a> AstNode<'a> for Block<'a> {
254 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 274 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
255} 275}
256 276
277impl<R: TreeRoot<RaTypes>> BlockNode<R> {
278 pub fn borrowed(&self) -> Block {
279 BlockNode { syntax: self.syntax.borrowed() }
280 }
281 pub fn owned(&self) -> BlockNode {
282 BlockNode { syntax: self.syntax.owned() }
283 }
284}
285
286
257impl<'a> Block<'a> { 287impl<'a> Block<'a> {
258 pub fn statements(self) -> impl Iterator<Item = Stmt<'a>> + 'a { 288 pub fn statements(self) -> impl Iterator<Item = Stmt<'a>> + 'a {
259 super::children(self) 289 super::children(self)
@@ -265,25 +295,18 @@ impl<'a> Block<'a> {
265} 295}
266 296
267// BlockExpr 297// BlockExpr
268 298#[derive(Debug, Clone, Copy,)]
269#[derive(Debug, Clone)] 299pub struct BlockExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
270pub struct BlockExprNode(SyntaxNode); 300 pub(crate) syntax: SyntaxNode<R>,
271
272impl BlockExprNode {
273 pub fn ast(&self) -> BlockExpr {
274 BlockExpr::cast(self.0.borrowed()).unwrap()
275 }
276} 301}
302pub type BlockExpr<'a> = BlockExprNode<RefRoot<'a>>;
277 303
278impl<'a> From<BlockExpr<'a>> for BlockExprNode { 304impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockExprNode<R1>> for BlockExprNode<R2> {
279 fn from(ast: BlockExpr<'a>) -> BlockExprNode { 305 fn eq(&self, other: &BlockExprNode<R1>) -> bool { self.syntax == other.syntax }
280 let syntax = ast.syntax().owned();
281 BlockExprNode(syntax)
282 }
283} 306}
284#[derive(Debug, Clone, Copy)] 307impl<R: TreeRoot<RaTypes>> Eq for BlockExprNode<R> {}
285pub struct BlockExpr<'a> { 308impl<R: TreeRoot<RaTypes>> Hash for BlockExprNode<R> {
286 syntax: SyntaxNodeRef<'a>, 309 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
287} 310}
288 311
289impl<'a> AstNode<'a> for BlockExpr<'a> { 312impl<'a> AstNode<'a> for BlockExpr<'a> {
@@ -296,6 +319,16 @@ impl<'a> AstNode<'a> for BlockExpr<'a> {
296 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 319 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
297} 320}
298 321
322impl<R: TreeRoot<RaTypes>> BlockExprNode<R> {
323 pub fn borrowed(&self) -> BlockExpr {
324 BlockExprNode { syntax: self.syntax.borrowed() }
325 }
326 pub fn owned(&self) -> BlockExprNode {
327 BlockExprNode { syntax: self.syntax.owned() }
328 }
329}
330
331
299impl<'a> BlockExpr<'a> { 332impl<'a> BlockExpr<'a> {
300 pub fn block(self) -> Option<Block<'a>> { 333 pub fn block(self) -> Option<Block<'a>> {
301 super::child_opt(self) 334 super::child_opt(self)
@@ -303,25 +336,18 @@ impl<'a> BlockExpr<'a> {
303} 336}
304 337
305// BreakExpr 338// BreakExpr
306 339#[derive(Debug, Clone, Copy,)]
307#[derive(Debug, Clone)] 340pub struct BreakExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
308pub struct BreakExprNode(SyntaxNode); 341 pub(crate) syntax: SyntaxNode<R>,
309
310impl BreakExprNode {
311 pub fn ast(&self) -> BreakExpr {
312 BreakExpr::cast(self.0.borrowed()).unwrap()
313 }
314} 342}
343pub type BreakExpr<'a> = BreakExprNode<RefRoot<'a>>;
315 344
316impl<'a> From<BreakExpr<'a>> for BreakExprNode { 345impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BreakExprNode<R1>> for BreakExprNode<R2> {
317 fn from(ast: BreakExpr<'a>) -> BreakExprNode { 346 fn eq(&self, other: &BreakExprNode<R1>) -> bool { self.syntax == other.syntax }
318 let syntax = ast.syntax().owned();
319 BreakExprNode(syntax)
320 }
321} 347}
322#[derive(Debug, Clone, Copy)] 348impl<R: TreeRoot<RaTypes>> Eq for BreakExprNode<R> {}
323pub struct BreakExpr<'a> { 349impl<R: TreeRoot<RaTypes>> Hash for BreakExprNode<R> {
324 syntax: SyntaxNodeRef<'a>, 350 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
325} 351}
326 352
327impl<'a> AstNode<'a> for BreakExpr<'a> { 353impl<'a> AstNode<'a> for BreakExpr<'a> {
@@ -334,28 +360,31 @@ impl<'a> AstNode<'a> for BreakExpr<'a> {
334 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 360 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
335} 361}
336 362
337impl<'a> BreakExpr<'a> {} 363impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
364 pub fn borrowed(&self) -> BreakExpr {
365 BreakExprNode { syntax: self.syntax.borrowed() }
366 }
367 pub fn owned(&self) -> BreakExprNode {
368 BreakExprNode { syntax: self.syntax.owned() }
369 }
370}
338 371
339// CallExpr
340 372
341#[derive(Debug, Clone)] 373impl<'a> BreakExpr<'a> {}
342pub struct CallExprNode(SyntaxNode);
343 374
344impl CallExprNode { 375// CallExpr
345 pub fn ast(&self) -> CallExpr { 376#[derive(Debug, Clone, Copy,)]
346 CallExpr::cast(self.0.borrowed()).unwrap() 377pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
347 } 378 pub(crate) syntax: SyntaxNode<R>,
348} 379}
380pub type CallExpr<'a> = CallExprNode<RefRoot<'a>>;
349 381
350impl<'a> From<CallExpr<'a>> for CallExprNode { 382impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CallExprNode<R1>> for CallExprNode<R2> {
351 fn from(ast: CallExpr<'a>) -> CallExprNode { 383 fn eq(&self, other: &CallExprNode<R1>) -> bool { self.syntax == other.syntax }
352 let syntax = ast.syntax().owned();
353 CallExprNode(syntax)
354 }
355} 384}
356#[derive(Debug, Clone, Copy)] 385impl<R: TreeRoot<RaTypes>> Eq for CallExprNode<R> {}
357pub struct CallExpr<'a> { 386impl<R: TreeRoot<RaTypes>> Hash for CallExprNode<R> {
358 syntax: SyntaxNodeRef<'a>, 387 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
359} 388}
360 389
361impl<'a> AstNode<'a> for CallExpr<'a> { 390impl<'a> AstNode<'a> for CallExpr<'a> {
@@ -368,6 +397,16 @@ impl<'a> AstNode<'a> for CallExpr<'a> {
368 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 397 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
369} 398}
370 399
400impl<R: TreeRoot<RaTypes>> CallExprNode<R> {
401 pub fn borrowed(&self) -> CallExpr {
402 CallExprNode { syntax: self.syntax.borrowed() }
403 }
404 pub fn owned(&self) -> CallExprNode {
405 CallExprNode { syntax: self.syntax.owned() }
406 }
407}
408
409
371impl<'a> ast::ArgListOwner<'a> for CallExpr<'a> {} 410impl<'a> ast::ArgListOwner<'a> for CallExpr<'a> {}
372impl<'a> CallExpr<'a> { 411impl<'a> CallExpr<'a> {
373 pub fn expr(self) -> Option<Expr<'a>> { 412 pub fn expr(self) -> Option<Expr<'a>> {
@@ -376,25 +415,18 @@ impl<'a> CallExpr<'a> {
376} 415}
377 416
378// CastExpr 417// CastExpr
379 418#[derive(Debug, Clone, Copy,)]
380#[derive(Debug, Clone)] 419pub struct CastExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
381pub struct CastExprNode(SyntaxNode); 420 pub(crate) syntax: SyntaxNode<R>,
382
383impl CastExprNode {
384 pub fn ast(&self) -> CastExpr {
385 CastExpr::cast(self.0.borrowed()).unwrap()
386 }
387} 421}
422pub type CastExpr<'a> = CastExprNode<RefRoot<'a>>;
388 423
389impl<'a> From<CastExpr<'a>> for CastExprNode { 424impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CastExprNode<R1>> for CastExprNode<R2> {
390 fn from(ast: CastExpr<'a>) -> CastExprNode { 425 fn eq(&self, other: &CastExprNode<R1>) -> bool { self.syntax == other.syntax }
391 let syntax = ast.syntax().owned();
392 CastExprNode(syntax)
393 }
394} 426}
395#[derive(Debug, Clone, Copy)] 427impl<R: TreeRoot<RaTypes>> Eq for CastExprNode<R> {}
396pub struct CastExpr<'a> { 428impl<R: TreeRoot<RaTypes>> Hash for CastExprNode<R> {
397 syntax: SyntaxNodeRef<'a>, 429 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
398} 430}
399 431
400impl<'a> AstNode<'a> for CastExpr<'a> { 432impl<'a> AstNode<'a> for CastExpr<'a> {
@@ -407,28 +439,31 @@ impl<'a> AstNode<'a> for CastExpr<'a> {
407 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 439 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
408} 440}
409 441
410impl<'a> CastExpr<'a> {} 442impl<R: TreeRoot<RaTypes>> CastExprNode<R> {
443 pub fn borrowed(&self) -> CastExpr {
444 CastExprNode { syntax: self.syntax.borrowed() }
445 }
446 pub fn owned(&self) -> CastExprNode {
447 CastExprNode { syntax: self.syntax.owned() }
448 }
449}
411 450
412// Char
413 451
414#[derive(Debug, Clone)] 452impl<'a> CastExpr<'a> {}
415pub struct CharNode(SyntaxNode);
416 453
417impl CharNode { 454// Char
418 pub fn ast(&self) -> Char { 455#[derive(Debug, Clone, Copy,)]
419 Char::cast(self.0.borrowed()).unwrap() 456pub struct CharNode<R: TreeRoot<RaTypes> = OwnedRoot> {
420 } 457 pub(crate) syntax: SyntaxNode<R>,
421} 458}
459pub type Char<'a> = CharNode<RefRoot<'a>>;
422 460
423impl<'a> From<Char<'a>> for CharNode { 461impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CharNode<R1>> for CharNode<R2> {
424 fn from(ast: Char<'a>) -> CharNode { 462 fn eq(&self, other: &CharNode<R1>) -> bool { self.syntax == other.syntax }
425 let syntax = ast.syntax().owned();
426 CharNode(syntax)
427 }
428} 463}
429#[derive(Debug, Clone, Copy)] 464impl<R: TreeRoot<RaTypes>> Eq for CharNode<R> {}
430pub struct Char<'a> { 465impl<R: TreeRoot<RaTypes>> Hash for CharNode<R> {
431 syntax: SyntaxNodeRef<'a>, 466 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
432} 467}
433 468
434impl<'a> AstNode<'a> for Char<'a> { 469impl<'a> AstNode<'a> for Char<'a> {
@@ -441,28 +476,31 @@ impl<'a> AstNode<'a> for Char<'a> {
441 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 476 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
442} 477}
443 478
444impl<'a> Char<'a> {} 479impl<R: TreeRoot<RaTypes>> CharNode<R> {
480 pub fn borrowed(&self) -> Char {
481 CharNode { syntax: self.syntax.borrowed() }
482 }
483 pub fn owned(&self) -> CharNode {
484 CharNode { syntax: self.syntax.owned() }
485 }
486}
445 487
446// Comment
447 488
448#[derive(Debug, Clone)] 489impl<'a> Char<'a> {}
449pub struct CommentNode(SyntaxNode);
450 490
451impl CommentNode { 491// Comment
452 pub fn ast(&self) -> Comment { 492#[derive(Debug, Clone, Copy,)]
453 Comment::cast(self.0.borrowed()).unwrap() 493pub struct CommentNode<R: TreeRoot<RaTypes> = OwnedRoot> {
454 } 494 pub(crate) syntax: SyntaxNode<R>,
455} 495}
496pub type Comment<'a> = CommentNode<RefRoot<'a>>;
456 497
457impl<'a> From<Comment<'a>> for CommentNode { 498impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CommentNode<R1>> for CommentNode<R2> {
458 fn from(ast: Comment<'a>) -> CommentNode { 499 fn eq(&self, other: &CommentNode<R1>) -> bool { self.syntax == other.syntax }
459 let syntax = ast.syntax().owned();
460 CommentNode(syntax)
461 }
462} 500}
463#[derive(Debug, Clone, Copy)] 501impl<R: TreeRoot<RaTypes>> Eq for CommentNode<R> {}
464pub struct Comment<'a> { 502impl<R: TreeRoot<RaTypes>> Hash for CommentNode<R> {
465 syntax: SyntaxNodeRef<'a>, 503 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
466} 504}
467 505
468impl<'a> AstNode<'a> for Comment<'a> { 506impl<'a> AstNode<'a> for Comment<'a> {
@@ -475,28 +513,31 @@ impl<'a> AstNode<'a> for Comment<'a> {
475 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 513 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
476} 514}
477 515
478impl<'a> Comment<'a> {} 516impl<R: TreeRoot<RaTypes>> CommentNode<R> {
517 pub fn borrowed(&self) -> Comment {
518 CommentNode { syntax: self.syntax.borrowed() }
519 }
520 pub fn owned(&self) -> CommentNode {
521 CommentNode { syntax: self.syntax.owned() }
522 }
523}
479 524
480// Condition
481 525
482#[derive(Debug, Clone)] 526impl<'a> Comment<'a> {}
483pub struct ConditionNode(SyntaxNode);
484 527
485impl ConditionNode { 528// Condition
486 pub fn ast(&self) -> Condition { 529#[derive(Debug, Clone, Copy,)]
487 Condition::cast(self.0.borrowed()).unwrap() 530pub struct ConditionNode<R: TreeRoot<RaTypes> = OwnedRoot> {
488 } 531 pub(crate) syntax: SyntaxNode<R>,
489} 532}
533pub type Condition<'a> = ConditionNode<RefRoot<'a>>;
490 534
491impl<'a> From<Condition<'a>> for ConditionNode { 535impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConditionNode<R1>> for ConditionNode<R2> {
492 fn from(ast: Condition<'a>) -> ConditionNode { 536 fn eq(&self, other: &ConditionNode<R1>) -> bool { self.syntax == other.syntax }
493 let syntax = ast.syntax().owned();
494 ConditionNode(syntax)
495 }
496} 537}
497#[derive(Debug, Clone, Copy)] 538impl<R: TreeRoot<RaTypes>> Eq for ConditionNode<R> {}
498pub struct Condition<'a> { 539impl<R: TreeRoot<RaTypes>> Hash for ConditionNode<R> {
499 syntax: SyntaxNodeRef<'a>, 540 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
500} 541}
501 542
502impl<'a> AstNode<'a> for Condition<'a> { 543impl<'a> AstNode<'a> for Condition<'a> {
@@ -509,6 +550,16 @@ impl<'a> AstNode<'a> for Condition<'a> {
509 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 550 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
510} 551}
511 552
553impl<R: TreeRoot<RaTypes>> ConditionNode<R> {
554 pub fn borrowed(&self) -> Condition {
555 ConditionNode { syntax: self.syntax.borrowed() }
556 }
557 pub fn owned(&self) -> ConditionNode {
558 ConditionNode { syntax: self.syntax.owned() }
559 }
560}
561
562
512impl<'a> Condition<'a> { 563impl<'a> Condition<'a> {
513 pub fn pat(self) -> Option<Pat<'a>> { 564 pub fn pat(self) -> Option<Pat<'a>> {
514 super::child_opt(self) 565 super::child_opt(self)
@@ -520,25 +571,18 @@ impl<'a> Condition<'a> {
520} 571}
521 572
522// ConstDef 573// ConstDef
523 574#[derive(Debug, Clone, Copy,)]
524#[derive(Debug, Clone)] 575pub struct ConstDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
525pub struct ConstDefNode(SyntaxNode); 576 pub(crate) syntax: SyntaxNode<R>,
526
527impl ConstDefNode {
528 pub fn ast(&self) -> ConstDef {
529 ConstDef::cast(self.0.borrowed()).unwrap()
530 }
531} 577}
578pub type ConstDef<'a> = ConstDefNode<RefRoot<'a>>;
532 579
533impl<'a> From<ConstDef<'a>> for ConstDefNode { 580impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConstDefNode<R1>> for ConstDefNode<R2> {
534 fn from(ast: ConstDef<'a>) -> ConstDefNode { 581 fn eq(&self, other: &ConstDefNode<R1>) -> bool { self.syntax == other.syntax }
535 let syntax = ast.syntax().owned();
536 ConstDefNode(syntax)
537 }
538} 582}
539#[derive(Debug, Clone, Copy)] 583impl<R: TreeRoot<RaTypes>> Eq for ConstDefNode<R> {}
540pub struct ConstDef<'a> { 584impl<R: TreeRoot<RaTypes>> Hash for ConstDefNode<R> {
541 syntax: SyntaxNodeRef<'a>, 585 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
542} 586}
543 587
544impl<'a> AstNode<'a> for ConstDef<'a> { 588impl<'a> AstNode<'a> for ConstDef<'a> {
@@ -551,31 +595,34 @@ impl<'a> AstNode<'a> for ConstDef<'a> {
551 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 595 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
552} 596}
553 597
598impl<R: TreeRoot<RaTypes>> ConstDefNode<R> {
599 pub fn borrowed(&self) -> ConstDef {
600 ConstDefNode { syntax: self.syntax.borrowed() }
601 }
602 pub fn owned(&self) -> ConstDefNode {
603 ConstDefNode { syntax: self.syntax.owned() }
604 }
605}
606
607
554impl<'a> ast::NameOwner<'a> for ConstDef<'a> {} 608impl<'a> ast::NameOwner<'a> for ConstDef<'a> {}
555impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {} 609impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {}
556impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {} 610impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {}
557impl<'a> ConstDef<'a> {} 611impl<'a> ConstDef<'a> {}
558 612
559// ContinueExpr 613// ContinueExpr
560 614#[derive(Debug, Clone, Copy,)]
561#[derive(Debug, Clone)] 615pub struct ContinueExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
562pub struct ContinueExprNode(SyntaxNode); 616 pub(crate) syntax: SyntaxNode<R>,
563
564impl ContinueExprNode {
565 pub fn ast(&self) -> ContinueExpr {
566 ContinueExpr::cast(self.0.borrowed()).unwrap()
567 }
568} 617}
618pub type ContinueExpr<'a> = ContinueExprNode<RefRoot<'a>>;
569 619
570impl<'a> From<ContinueExpr<'a>> for ContinueExprNode { 620impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ContinueExprNode<R1>> for ContinueExprNode<R2> {
571 fn from(ast: ContinueExpr<'a>) -> ContinueExprNode { 621 fn eq(&self, other: &ContinueExprNode<R1>) -> bool { self.syntax == other.syntax }
572 let syntax = ast.syntax().owned();
573 ContinueExprNode(syntax)
574 }
575} 622}
576#[derive(Debug, Clone, Copy)] 623impl<R: TreeRoot<RaTypes>> Eq for ContinueExprNode<R> {}
577pub struct ContinueExpr<'a> { 624impl<R: TreeRoot<RaTypes>> Hash for ContinueExprNode<R> {
578 syntax: SyntaxNodeRef<'a>, 625 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
579} 626}
580 627
581impl<'a> AstNode<'a> for ContinueExpr<'a> { 628impl<'a> AstNode<'a> for ContinueExpr<'a> {
@@ -588,28 +635,31 @@ impl<'a> AstNode<'a> for ContinueExpr<'a> {
588 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 635 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
589} 636}
590 637
591impl<'a> ContinueExpr<'a> {} 638impl<R: TreeRoot<RaTypes>> ContinueExprNode<R> {
639 pub fn borrowed(&self) -> ContinueExpr {
640 ContinueExprNode { syntax: self.syntax.borrowed() }
641 }
642 pub fn owned(&self) -> ContinueExprNode {
643 ContinueExprNode { syntax: self.syntax.owned() }
644 }
645}
592 646
593// DynTraitType
594 647
595#[derive(Debug, Clone)] 648impl<'a> ContinueExpr<'a> {}
596pub struct DynTraitTypeNode(SyntaxNode);
597 649
598impl DynTraitTypeNode { 650// DynTraitType
599 pub fn ast(&self) -> DynTraitType { 651#[derive(Debug, Clone, Copy,)]
600 DynTraitType::cast(self.0.borrowed()).unwrap() 652pub struct DynTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
601 } 653 pub(crate) syntax: SyntaxNode<R>,
602} 654}
655pub type DynTraitType<'a> = DynTraitTypeNode<RefRoot<'a>>;
603 656
604impl<'a> From<DynTraitType<'a>> for DynTraitTypeNode { 657impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<DynTraitTypeNode<R1>> for DynTraitTypeNode<R2> {
605 fn from(ast: DynTraitType<'a>) -> DynTraitTypeNode { 658 fn eq(&self, other: &DynTraitTypeNode<R1>) -> bool { self.syntax == other.syntax }
606 let syntax = ast.syntax().owned();
607 DynTraitTypeNode(syntax)
608 }
609} 659}
610#[derive(Debug, Clone, Copy)] 660impl<R: TreeRoot<RaTypes>> Eq for DynTraitTypeNode<R> {}
611pub struct DynTraitType<'a> { 661impl<R: TreeRoot<RaTypes>> Hash for DynTraitTypeNode<R> {
612 syntax: SyntaxNodeRef<'a>, 662 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
613} 663}
614 664
615impl<'a> AstNode<'a> for DynTraitType<'a> { 665impl<'a> AstNode<'a> for DynTraitType<'a> {
@@ -622,28 +672,31 @@ impl<'a> AstNode<'a> for DynTraitType<'a> {
622 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 672 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
623} 673}
624 674
625impl<'a> DynTraitType<'a> {} 675impl<R: TreeRoot<RaTypes>> DynTraitTypeNode<R> {
676 pub fn borrowed(&self) -> DynTraitType {
677 DynTraitTypeNode { syntax: self.syntax.borrowed() }
678 }
679 pub fn owned(&self) -> DynTraitTypeNode {
680 DynTraitTypeNode { syntax: self.syntax.owned() }
681 }
682}
626 683
627// EnumDef
628 684
629#[derive(Debug, Clone)] 685impl<'a> DynTraitType<'a> {}
630pub struct EnumDefNode(SyntaxNode);
631 686
632impl EnumDefNode { 687// EnumDef
633 pub fn ast(&self) -> EnumDef { 688#[derive(Debug, Clone, Copy,)]
634 EnumDef::cast(self.0.borrowed()).unwrap() 689pub struct EnumDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
635 } 690 pub(crate) syntax: SyntaxNode<R>,
636} 691}
692pub type EnumDef<'a> = EnumDefNode<RefRoot<'a>>;
637 693
638impl<'a> From<EnumDef<'a>> for EnumDefNode { 694impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumDefNode<R1>> for EnumDefNode<R2> {
639 fn from(ast: EnumDef<'a>) -> EnumDefNode { 695 fn eq(&self, other: &EnumDefNode<R1>) -> bool { self.syntax == other.syntax }
640 let syntax = ast.syntax().owned();
641 EnumDefNode(syntax)
642 }
643} 696}
644#[derive(Debug, Clone, Copy)] 697impl<R: TreeRoot<RaTypes>> Eq for EnumDefNode<R> {}
645pub struct EnumDef<'a> { 698impl<R: TreeRoot<RaTypes>> Hash for EnumDefNode<R> {
646 syntax: SyntaxNodeRef<'a>, 699 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
647} 700}
648 701
649impl<'a> AstNode<'a> for EnumDef<'a> { 702impl<'a> AstNode<'a> for EnumDef<'a> {
@@ -656,29 +709,23 @@ impl<'a> AstNode<'a> for EnumDef<'a> {
656 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 709 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
657} 710}
658 711
712impl<R: TreeRoot<RaTypes>> EnumDefNode<R> {
713 pub fn borrowed(&self) -> EnumDef {
714 EnumDefNode { syntax: self.syntax.borrowed() }
715 }
716 pub fn owned(&self) -> EnumDefNode {
717 EnumDefNode { syntax: self.syntax.owned() }
718 }
719}
720
721
659impl<'a> ast::NameOwner<'a> for EnumDef<'a> {} 722impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
660impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {} 723impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
661impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {} 724impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
662impl<'a> EnumDef<'a> {} 725impl<'a> EnumDef<'a> {}
663 726
664// Expr 727// Expr
665 728#[derive(Debug, Clone, Copy, PartialEq, Eq)]
666#[derive(Debug, Clone)]
667pub struct ExprNode(SyntaxNode);
668
669impl ExprNode {
670 pub fn ast(&self) -> Expr {
671 Expr::cast(self.0.borrowed()).unwrap()
672 }
673}
674
675impl<'a> From<Expr<'a>> for ExprNode {
676 fn from(ast: Expr<'a>) -> ExprNode {
677 let syntax = ast.syntax().owned();
678 ExprNode(syntax)
679 }
680}
681#[derive(Debug, Clone, Copy)]
682pub enum Expr<'a> { 729pub enum Expr<'a> {
683 TupleExpr(TupleExpr<'a>), 730 TupleExpr(TupleExpr<'a>),
684 ArrayExpr(ArrayExpr<'a>), 731 ArrayExpr(ArrayExpr<'a>),
@@ -793,25 +840,18 @@ impl<'a> AstNode<'a> for Expr<'a> {
793impl<'a> Expr<'a> {} 840impl<'a> Expr<'a> {}
794 841
795// ExprStmt 842// ExprStmt
796 843#[derive(Debug, Clone, Copy,)]
797#[derive(Debug, Clone)] 844pub struct ExprStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> {
798pub struct ExprStmtNode(SyntaxNode); 845 pub(crate) syntax: SyntaxNode<R>,
799
800impl ExprStmtNode {
801 pub fn ast(&self) -> ExprStmt {
802 ExprStmt::cast(self.0.borrowed()).unwrap()
803 }
804} 846}
847pub type ExprStmt<'a> = ExprStmtNode<RefRoot<'a>>;
805 848
806impl<'a> From<ExprStmt<'a>> for ExprStmtNode { 849impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExprStmtNode<R1>> for ExprStmtNode<R2> {
807 fn from(ast: ExprStmt<'a>) -> ExprStmtNode { 850 fn eq(&self, other: &ExprStmtNode<R1>) -> bool { self.syntax == other.syntax }
808 let syntax = ast.syntax().owned();
809 ExprStmtNode(syntax)
810 }
811} 851}
812#[derive(Debug, Clone, Copy)] 852impl<R: TreeRoot<RaTypes>> Eq for ExprStmtNode<R> {}
813pub struct ExprStmt<'a> { 853impl<R: TreeRoot<RaTypes>> Hash for ExprStmtNode<R> {
814 syntax: SyntaxNodeRef<'a>, 854 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
815} 855}
816 856
817impl<'a> AstNode<'a> for ExprStmt<'a> { 857impl<'a> AstNode<'a> for ExprStmt<'a> {
@@ -824,6 +864,16 @@ impl<'a> AstNode<'a> for ExprStmt<'a> {
824 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 864 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
825} 865}
826 866
867impl<R: TreeRoot<RaTypes>> ExprStmtNode<R> {
868 pub fn borrowed(&self) -> ExprStmt {
869 ExprStmtNode { syntax: self.syntax.borrowed() }
870 }
871 pub fn owned(&self) -> ExprStmtNode {
872 ExprStmtNode { syntax: self.syntax.owned() }
873 }
874}
875
876
827impl<'a> ExprStmt<'a> { 877impl<'a> ExprStmt<'a> {
828 pub fn expr(self) -> Option<Expr<'a>> { 878 pub fn expr(self) -> Option<Expr<'a>> {
829 super::child_opt(self) 879 super::child_opt(self)
@@ -831,25 +881,18 @@ impl<'a> ExprStmt<'a> {
831} 881}
832 882
833// ExternCrateItem 883// ExternCrateItem
834 884#[derive(Debug, Clone, Copy,)]
835#[derive(Debug, Clone)] 885pub struct ExternCrateItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
836pub struct ExternCrateItemNode(SyntaxNode); 886 pub(crate) syntax: SyntaxNode<R>,
837
838impl ExternCrateItemNode {
839 pub fn ast(&self) -> ExternCrateItem {
840 ExternCrateItem::cast(self.0.borrowed()).unwrap()
841 }
842} 887}
888pub type ExternCrateItem<'a> = ExternCrateItemNode<RefRoot<'a>>;
843 889
844impl<'a> From<ExternCrateItem<'a>> for ExternCrateItemNode { 890impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExternCrateItemNode<R1>> for ExternCrateItemNode<R2> {
845 fn from(ast: ExternCrateItem<'a>) -> ExternCrateItemNode { 891 fn eq(&self, other: &ExternCrateItemNode<R1>) -> bool { self.syntax == other.syntax }
846 let syntax = ast.syntax().owned();
847 ExternCrateItemNode(syntax)
848 }
849} 892}
850#[derive(Debug, Clone, Copy)] 893impl<R: TreeRoot<RaTypes>> Eq for ExternCrateItemNode<R> {}
851pub struct ExternCrateItem<'a> { 894impl<R: TreeRoot<RaTypes>> Hash for ExternCrateItemNode<R> {
852 syntax: SyntaxNodeRef<'a>, 895 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
853} 896}
854 897
855impl<'a> AstNode<'a> for ExternCrateItem<'a> { 898impl<'a> AstNode<'a> for ExternCrateItem<'a> {
@@ -862,28 +905,31 @@ impl<'a> AstNode<'a> for ExternCrateItem<'a> {
862 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 905 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
863} 906}
864 907
865impl<'a> ExternCrateItem<'a> {} 908impl<R: TreeRoot<RaTypes>> ExternCrateItemNode<R> {
909 pub fn borrowed(&self) -> ExternCrateItem {
910 ExternCrateItemNode { syntax: self.syntax.borrowed() }
911 }
912 pub fn owned(&self) -> ExternCrateItemNode {
913 ExternCrateItemNode { syntax: self.syntax.owned() }
914 }
915}
866 916
867// FieldExpr
868 917
869#[derive(Debug, Clone)] 918impl<'a> ExternCrateItem<'a> {}
870pub struct FieldExprNode(SyntaxNode);
871 919
872impl FieldExprNode { 920// FieldExpr
873 pub fn ast(&self) -> FieldExpr { 921#[derive(Debug, Clone, Copy,)]
874 FieldExpr::cast(self.0.borrowed()).unwrap() 922pub struct FieldExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
875 } 923 pub(crate) syntax: SyntaxNode<R>,
876} 924}
925pub type FieldExpr<'a> = FieldExprNode<RefRoot<'a>>;
877 926
878impl<'a> From<FieldExpr<'a>> for FieldExprNode { 927impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldExprNode<R1>> for FieldExprNode<R2> {
879 fn from(ast: FieldExpr<'a>) -> FieldExprNode { 928 fn eq(&self, other: &FieldExprNode<R1>) -> bool { self.syntax == other.syntax }
880 let syntax = ast.syntax().owned();
881 FieldExprNode(syntax)
882 }
883} 929}
884#[derive(Debug, Clone, Copy)] 930impl<R: TreeRoot<RaTypes>> Eq for FieldExprNode<R> {}
885pub struct FieldExpr<'a> { 931impl<R: TreeRoot<RaTypes>> Hash for FieldExprNode<R> {
886 syntax: SyntaxNodeRef<'a>, 932 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
887} 933}
888 934
889impl<'a> AstNode<'a> for FieldExpr<'a> { 935impl<'a> AstNode<'a> for FieldExpr<'a> {
@@ -896,28 +942,31 @@ impl<'a> AstNode<'a> for FieldExpr<'a> {
896 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 942 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
897} 943}
898 944
899impl<'a> FieldExpr<'a> {} 945impl<R: TreeRoot<RaTypes>> FieldExprNode<R> {
946 pub fn borrowed(&self) -> FieldExpr {
947 FieldExprNode { syntax: self.syntax.borrowed() }
948 }
949 pub fn owned(&self) -> FieldExprNode {
950 FieldExprNode { syntax: self.syntax.owned() }
951 }
952}
900 953
901// FieldPatList
902 954
903#[derive(Debug, Clone)] 955impl<'a> FieldExpr<'a> {}
904pub struct FieldPatListNode(SyntaxNode);
905 956
906impl FieldPatListNode { 957// FieldPatList
907 pub fn ast(&self) -> FieldPatList { 958#[derive(Debug, Clone, Copy,)]
908 FieldPatList::cast(self.0.borrowed()).unwrap() 959pub struct FieldPatListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
909 } 960 pub(crate) syntax: SyntaxNode<R>,
910} 961}
962pub type FieldPatList<'a> = FieldPatListNode<RefRoot<'a>>;
911 963
912impl<'a> From<FieldPatList<'a>> for FieldPatListNode { 964impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldPatListNode<R1>> for FieldPatListNode<R2> {
913 fn from(ast: FieldPatList<'a>) -> FieldPatListNode { 965 fn eq(&self, other: &FieldPatListNode<R1>) -> bool { self.syntax == other.syntax }
914 let syntax = ast.syntax().owned();
915 FieldPatListNode(syntax)
916 }
917} 966}
918#[derive(Debug, Clone, Copy)] 967impl<R: TreeRoot<RaTypes>> Eq for FieldPatListNode<R> {}
919pub struct FieldPatList<'a> { 968impl<R: TreeRoot<RaTypes>> Hash for FieldPatListNode<R> {
920 syntax: SyntaxNodeRef<'a>, 969 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
921} 970}
922 971
923impl<'a> AstNode<'a> for FieldPatList<'a> { 972impl<'a> AstNode<'a> for FieldPatList<'a> {
@@ -930,28 +979,31 @@ impl<'a> AstNode<'a> for FieldPatList<'a> {
930 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 979 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
931} 980}
932 981
933impl<'a> FieldPatList<'a> {} 982impl<R: TreeRoot<RaTypes>> FieldPatListNode<R> {
983 pub fn borrowed(&self) -> FieldPatList {
984 FieldPatListNode { syntax: self.syntax.borrowed() }
985 }
986 pub fn owned(&self) -> FieldPatListNode {
987 FieldPatListNode { syntax: self.syntax.owned() }
988 }
989}
934 990
935// FnDef
936 991
937#[derive(Debug, Clone)] 992impl<'a> FieldPatList<'a> {}
938pub struct FnDefNode(SyntaxNode);
939 993
940impl FnDefNode { 994// FnDef
941 pub fn ast(&self) -> FnDef { 995#[derive(Debug, Clone, Copy,)]
942 FnDef::cast(self.0.borrowed()).unwrap() 996pub struct FnDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
943 } 997 pub(crate) syntax: SyntaxNode<R>,
944} 998}
999pub type FnDef<'a> = FnDefNode<RefRoot<'a>>;
945 1000
946impl<'a> From<FnDef<'a>> for FnDefNode { 1001impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnDefNode<R1>> for FnDefNode<R2> {
947 fn from(ast: FnDef<'a>) -> FnDefNode { 1002 fn eq(&self, other: &FnDefNode<R1>) -> bool { self.syntax == other.syntax }
948 let syntax = ast.syntax().owned();
949 FnDefNode(syntax)
950 }
951} 1003}
952#[derive(Debug, Clone, Copy)] 1004impl<R: TreeRoot<RaTypes>> Eq for FnDefNode<R> {}
953pub struct FnDef<'a> { 1005impl<R: TreeRoot<RaTypes>> Hash for FnDefNode<R> {
954 syntax: SyntaxNodeRef<'a>, 1006 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
955} 1007}
956 1008
957impl<'a> AstNode<'a> for FnDef<'a> { 1009impl<'a> AstNode<'a> for FnDef<'a> {
@@ -964,6 +1016,16 @@ impl<'a> AstNode<'a> for FnDef<'a> {
964 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1016 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
965} 1017}
966 1018
1019impl<R: TreeRoot<RaTypes>> FnDefNode<R> {
1020 pub fn borrowed(&self) -> FnDef {
1021 FnDefNode { syntax: self.syntax.borrowed() }
1022 }
1023 pub fn owned(&self) -> FnDefNode {
1024 FnDefNode { syntax: self.syntax.owned() }
1025 }
1026}
1027
1028
967impl<'a> ast::NameOwner<'a> for FnDef<'a> {} 1029impl<'a> ast::NameOwner<'a> for FnDef<'a> {}
968impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {} 1030impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {}
969impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {} 1031impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {}
@@ -983,25 +1045,18 @@ impl<'a> FnDef<'a> {
983} 1045}
984 1046
985// FnPointerType 1047// FnPointerType
986 1048#[derive(Debug, Clone, Copy,)]
987#[derive(Debug, Clone)] 1049pub struct FnPointerTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
988pub struct FnPointerTypeNode(SyntaxNode); 1050 pub(crate) syntax: SyntaxNode<R>,
989
990impl FnPointerTypeNode {
991 pub fn ast(&self) -> FnPointerType {
992 FnPointerType::cast(self.0.borrowed()).unwrap()
993 }
994} 1051}
1052pub type FnPointerType<'a> = FnPointerTypeNode<RefRoot<'a>>;
995 1053
996impl<'a> From<FnPointerType<'a>> for FnPointerTypeNode { 1054impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnPointerTypeNode<R1>> for FnPointerTypeNode<R2> {
997 fn from(ast: FnPointerType<'a>) -> FnPointerTypeNode { 1055 fn eq(&self, other: &FnPointerTypeNode<R1>) -> bool { self.syntax == other.syntax }
998 let syntax = ast.syntax().owned();
999 FnPointerTypeNode(syntax)
1000 }
1001} 1056}
1002#[derive(Debug, Clone, Copy)] 1057impl<R: TreeRoot<RaTypes>> Eq for FnPointerTypeNode<R> {}
1003pub struct FnPointerType<'a> { 1058impl<R: TreeRoot<RaTypes>> Hash for FnPointerTypeNode<R> {
1004 syntax: SyntaxNodeRef<'a>, 1059 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1005} 1060}
1006 1061
1007impl<'a> AstNode<'a> for FnPointerType<'a> { 1062impl<'a> AstNode<'a> for FnPointerType<'a> {
@@ -1014,28 +1069,31 @@ impl<'a> AstNode<'a> for FnPointerType<'a> {
1014 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1069 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1015} 1070}
1016 1071
1017impl<'a> FnPointerType<'a> {} 1072impl<R: TreeRoot<RaTypes>> FnPointerTypeNode<R> {
1073 pub fn borrowed(&self) -> FnPointerType {
1074 FnPointerTypeNode { syntax: self.syntax.borrowed() }
1075 }
1076 pub fn owned(&self) -> FnPointerTypeNode {
1077 FnPointerTypeNode { syntax: self.syntax.owned() }
1078 }
1079}
1018 1080
1019// ForExpr
1020 1081
1021#[derive(Debug, Clone)] 1082impl<'a> FnPointerType<'a> {}
1022pub struct ForExprNode(SyntaxNode);
1023 1083
1024impl ForExprNode { 1084// ForExpr
1025 pub fn ast(&self) -> ForExpr { 1085#[derive(Debug, Clone, Copy,)]
1026 ForExpr::cast(self.0.borrowed()).unwrap() 1086pub struct ForExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1027 } 1087 pub(crate) syntax: SyntaxNode<R>,
1028} 1088}
1089pub type ForExpr<'a> = ForExprNode<RefRoot<'a>>;
1029 1090
1030impl<'a> From<ForExpr<'a>> for ForExprNode { 1091impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForExprNode<R1>> for ForExprNode<R2> {
1031 fn from(ast: ForExpr<'a>) -> ForExprNode { 1092 fn eq(&self, other: &ForExprNode<R1>) -> bool { self.syntax == other.syntax }
1032 let syntax = ast.syntax().owned();
1033 ForExprNode(syntax)
1034 }
1035} 1093}
1036#[derive(Debug, Clone, Copy)] 1094impl<R: TreeRoot<RaTypes>> Eq for ForExprNode<R> {}
1037pub struct ForExpr<'a> { 1095impl<R: TreeRoot<RaTypes>> Hash for ForExprNode<R> {
1038 syntax: SyntaxNodeRef<'a>, 1096 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1039} 1097}
1040 1098
1041impl<'a> AstNode<'a> for ForExpr<'a> { 1099impl<'a> AstNode<'a> for ForExpr<'a> {
@@ -1048,6 +1106,16 @@ impl<'a> AstNode<'a> for ForExpr<'a> {
1048 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1106 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1049} 1107}
1050 1108
1109impl<R: TreeRoot<RaTypes>> ForExprNode<R> {
1110 pub fn borrowed(&self) -> ForExpr {
1111 ForExprNode { syntax: self.syntax.borrowed() }
1112 }
1113 pub fn owned(&self) -> ForExprNode {
1114 ForExprNode { syntax: self.syntax.owned() }
1115 }
1116}
1117
1118
1051impl<'a> ast::LoopBodyOwner<'a> for ForExpr<'a> {} 1119impl<'a> ast::LoopBodyOwner<'a> for ForExpr<'a> {}
1052impl<'a> ForExpr<'a> { 1120impl<'a> ForExpr<'a> {
1053 pub fn pat(self) -> Option<Pat<'a>> { 1121 pub fn pat(self) -> Option<Pat<'a>> {
@@ -1060,25 +1128,18 @@ impl<'a> ForExpr<'a> {
1060} 1128}
1061 1129
1062// ForType 1130// ForType
1063 1131#[derive(Debug, Clone, Copy,)]
1064#[derive(Debug, Clone)] 1132pub struct ForTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1065pub struct ForTypeNode(SyntaxNode); 1133 pub(crate) syntax: SyntaxNode<R>,
1066
1067impl ForTypeNode {
1068 pub fn ast(&self) -> ForType {
1069 ForType::cast(self.0.borrowed()).unwrap()
1070 }
1071} 1134}
1135pub type ForType<'a> = ForTypeNode<RefRoot<'a>>;
1072 1136
1073impl<'a> From<ForType<'a>> for ForTypeNode { 1137impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForTypeNode<R1>> for ForTypeNode<R2> {
1074 fn from(ast: ForType<'a>) -> ForTypeNode { 1138 fn eq(&self, other: &ForTypeNode<R1>) -> bool { self.syntax == other.syntax }
1075 let syntax = ast.syntax().owned();
1076 ForTypeNode(syntax)
1077 }
1078} 1139}
1079#[derive(Debug, Clone, Copy)] 1140impl<R: TreeRoot<RaTypes>> Eq for ForTypeNode<R> {}
1080pub struct ForType<'a> { 1141impl<R: TreeRoot<RaTypes>> Hash for ForTypeNode<R> {
1081 syntax: SyntaxNodeRef<'a>, 1142 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1082} 1143}
1083 1144
1084impl<'a> AstNode<'a> for ForType<'a> { 1145impl<'a> AstNode<'a> for ForType<'a> {
@@ -1091,28 +1152,31 @@ impl<'a> AstNode<'a> for ForType<'a> {
1091 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1152 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1092} 1153}
1093 1154
1094impl<'a> ForType<'a> {} 1155impl<R: TreeRoot<RaTypes>> ForTypeNode<R> {
1156 pub fn borrowed(&self) -> ForType {
1157 ForTypeNode { syntax: self.syntax.borrowed() }
1158 }
1159 pub fn owned(&self) -> ForTypeNode {
1160 ForTypeNode { syntax: self.syntax.owned() }
1161 }
1162}
1095 1163
1096// IfExpr
1097 1164
1098#[derive(Debug, Clone)] 1165impl<'a> ForType<'a> {}
1099pub struct IfExprNode(SyntaxNode);
1100 1166
1101impl IfExprNode { 1167// IfExpr
1102 pub fn ast(&self) -> IfExpr { 1168#[derive(Debug, Clone, Copy,)]
1103 IfExpr::cast(self.0.borrowed()).unwrap() 1169pub struct IfExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1104 } 1170 pub(crate) syntax: SyntaxNode<R>,
1105} 1171}
1172pub type IfExpr<'a> = IfExprNode<RefRoot<'a>>;
1106 1173
1107impl<'a> From<IfExpr<'a>> for IfExprNode { 1174impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IfExprNode<R1>> for IfExprNode<R2> {
1108 fn from(ast: IfExpr<'a>) -> IfExprNode { 1175 fn eq(&self, other: &IfExprNode<R1>) -> bool { self.syntax == other.syntax }
1109 let syntax = ast.syntax().owned();
1110 IfExprNode(syntax)
1111 }
1112} 1176}
1113#[derive(Debug, Clone, Copy)] 1177impl<R: TreeRoot<RaTypes>> Eq for IfExprNode<R> {}
1114pub struct IfExpr<'a> { 1178impl<R: TreeRoot<RaTypes>> Hash for IfExprNode<R> {
1115 syntax: SyntaxNodeRef<'a>, 1179 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1116} 1180}
1117 1181
1118impl<'a> AstNode<'a> for IfExpr<'a> { 1182impl<'a> AstNode<'a> for IfExpr<'a> {
@@ -1125,6 +1189,16 @@ impl<'a> AstNode<'a> for IfExpr<'a> {
1125 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1189 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1126} 1190}
1127 1191
1192impl<R: TreeRoot<RaTypes>> IfExprNode<R> {
1193 pub fn borrowed(&self) -> IfExpr {
1194 IfExprNode { syntax: self.syntax.borrowed() }
1195 }
1196 pub fn owned(&self) -> IfExprNode {
1197 IfExprNode { syntax: self.syntax.owned() }
1198 }
1199}
1200
1201
1128impl<'a> IfExpr<'a> { 1202impl<'a> IfExpr<'a> {
1129 pub fn condition(self) -> Option<Condition<'a>> { 1203 pub fn condition(self) -> Option<Condition<'a>> {
1130 super::child_opt(self) 1204 super::child_opt(self)
@@ -1132,25 +1206,18 @@ impl<'a> IfExpr<'a> {
1132} 1206}
1133 1207
1134// ImplItem 1208// ImplItem
1135 1209#[derive(Debug, Clone, Copy,)]
1136#[derive(Debug, Clone)] 1210pub struct ImplItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1137pub struct ImplItemNode(SyntaxNode); 1211 pub(crate) syntax: SyntaxNode<R>,
1138
1139impl ImplItemNode {
1140 pub fn ast(&self) -> ImplItem {
1141 ImplItem::cast(self.0.borrowed()).unwrap()
1142 }
1143} 1212}
1213pub type ImplItem<'a> = ImplItemNode<RefRoot<'a>>;
1144 1214
1145impl<'a> From<ImplItem<'a>> for ImplItemNode { 1215impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplItemNode<R1>> for ImplItemNode<R2> {
1146 fn from(ast: ImplItem<'a>) -> ImplItemNode { 1216 fn eq(&self, other: &ImplItemNode<R1>) -> bool { self.syntax == other.syntax }
1147 let syntax = ast.syntax().owned();
1148 ImplItemNode(syntax)
1149 }
1150} 1217}
1151#[derive(Debug, Clone, Copy)] 1218impl<R: TreeRoot<RaTypes>> Eq for ImplItemNode<R> {}
1152pub struct ImplItem<'a> { 1219impl<R: TreeRoot<RaTypes>> Hash for ImplItemNode<R> {
1153 syntax: SyntaxNodeRef<'a>, 1220 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1154} 1221}
1155 1222
1156impl<'a> AstNode<'a> for ImplItem<'a> { 1223impl<'a> AstNode<'a> for ImplItem<'a> {
@@ -1163,28 +1230,31 @@ impl<'a> AstNode<'a> for ImplItem<'a> {
1163 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1230 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1164} 1231}
1165 1232
1166impl<'a> ImplItem<'a> {} 1233impl<R: TreeRoot<RaTypes>> ImplItemNode<R> {
1234 pub fn borrowed(&self) -> ImplItem {
1235 ImplItemNode { syntax: self.syntax.borrowed() }
1236 }
1237 pub fn owned(&self) -> ImplItemNode {
1238 ImplItemNode { syntax: self.syntax.owned() }
1239 }
1240}
1167 1241
1168// ImplTraitType
1169 1242
1170#[derive(Debug, Clone)] 1243impl<'a> ImplItem<'a> {}
1171pub struct ImplTraitTypeNode(SyntaxNode);
1172 1244
1173impl ImplTraitTypeNode { 1245// ImplTraitType
1174 pub fn ast(&self) -> ImplTraitType { 1246#[derive(Debug, Clone, Copy,)]
1175 ImplTraitType::cast(self.0.borrowed()).unwrap() 1247pub struct ImplTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1176 } 1248 pub(crate) syntax: SyntaxNode<R>,
1177} 1249}
1250pub type ImplTraitType<'a> = ImplTraitTypeNode<RefRoot<'a>>;
1178 1251
1179impl<'a> From<ImplTraitType<'a>> for ImplTraitTypeNode { 1252impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplTraitTypeNode<R1>> for ImplTraitTypeNode<R2> {
1180 fn from(ast: ImplTraitType<'a>) -> ImplTraitTypeNode { 1253 fn eq(&self, other: &ImplTraitTypeNode<R1>) -> bool { self.syntax == other.syntax }
1181 let syntax = ast.syntax().owned();
1182 ImplTraitTypeNode(syntax)
1183 }
1184} 1254}
1185#[derive(Debug, Clone, Copy)] 1255impl<R: TreeRoot<RaTypes>> Eq for ImplTraitTypeNode<R> {}
1186pub struct ImplTraitType<'a> { 1256impl<R: TreeRoot<RaTypes>> Hash for ImplTraitTypeNode<R> {
1187 syntax: SyntaxNodeRef<'a>, 1257 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1188} 1258}
1189 1259
1190impl<'a> AstNode<'a> for ImplTraitType<'a> { 1260impl<'a> AstNode<'a> for ImplTraitType<'a> {
@@ -1197,28 +1267,31 @@ impl<'a> AstNode<'a> for ImplTraitType<'a> {
1197 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1267 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1198} 1268}
1199 1269
1200impl<'a> ImplTraitType<'a> {} 1270impl<R: TreeRoot<RaTypes>> ImplTraitTypeNode<R> {
1271 pub fn borrowed(&self) -> ImplTraitType {
1272 ImplTraitTypeNode { syntax: self.syntax.borrowed() }
1273 }
1274 pub fn owned(&self) -> ImplTraitTypeNode {
1275 ImplTraitTypeNode { syntax: self.syntax.owned() }
1276 }
1277}
1201 1278
1202// IndexExpr
1203 1279
1204#[derive(Debug, Clone)] 1280impl<'a> ImplTraitType<'a> {}
1205pub struct IndexExprNode(SyntaxNode);
1206 1281
1207impl IndexExprNode { 1282// IndexExpr
1208 pub fn ast(&self) -> IndexExpr { 1283#[derive(Debug, Clone, Copy,)]
1209 IndexExpr::cast(self.0.borrowed()).unwrap() 1284pub struct IndexExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1210 } 1285 pub(crate) syntax: SyntaxNode<R>,
1211} 1286}
1287pub type IndexExpr<'a> = IndexExprNode<RefRoot<'a>>;
1212 1288
1213impl<'a> From<IndexExpr<'a>> for IndexExprNode { 1289impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IndexExprNode<R1>> for IndexExprNode<R2> {
1214 fn from(ast: IndexExpr<'a>) -> IndexExprNode { 1290 fn eq(&self, other: &IndexExprNode<R1>) -> bool { self.syntax == other.syntax }
1215 let syntax = ast.syntax().owned();
1216 IndexExprNode(syntax)
1217 }
1218} 1291}
1219#[derive(Debug, Clone, Copy)] 1292impl<R: TreeRoot<RaTypes>> Eq for IndexExprNode<R> {}
1220pub struct IndexExpr<'a> { 1293impl<R: TreeRoot<RaTypes>> Hash for IndexExprNode<R> {
1221 syntax: SyntaxNodeRef<'a>, 1294 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1222} 1295}
1223 1296
1224impl<'a> AstNode<'a> for IndexExpr<'a> { 1297impl<'a> AstNode<'a> for IndexExpr<'a> {
@@ -1231,28 +1304,31 @@ impl<'a> AstNode<'a> for IndexExpr<'a> {
1231 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1304 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1232} 1305}
1233 1306
1234impl<'a> IndexExpr<'a> {} 1307impl<R: TreeRoot<RaTypes>> IndexExprNode<R> {
1308 pub fn borrowed(&self) -> IndexExpr {
1309 IndexExprNode { syntax: self.syntax.borrowed() }
1310 }
1311 pub fn owned(&self) -> IndexExprNode {
1312 IndexExprNode { syntax: self.syntax.owned() }
1313 }
1314}
1235 1315
1236// ItemList
1237 1316
1238#[derive(Debug, Clone)] 1317impl<'a> IndexExpr<'a> {}
1239pub struct ItemListNode(SyntaxNode);
1240 1318
1241impl ItemListNode { 1319// ItemList
1242 pub fn ast(&self) -> ItemList { 1320#[derive(Debug, Clone, Copy,)]
1243 ItemList::cast(self.0.borrowed()).unwrap() 1321pub struct ItemListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1244 } 1322 pub(crate) syntax: SyntaxNode<R>,
1245} 1323}
1324pub type ItemList<'a> = ItemListNode<RefRoot<'a>>;
1246 1325
1247impl<'a> From<ItemList<'a>> for ItemListNode { 1326impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ItemListNode<R1>> for ItemListNode<R2> {
1248 fn from(ast: ItemList<'a>) -> ItemListNode { 1327 fn eq(&self, other: &ItemListNode<R1>) -> bool { self.syntax == other.syntax }
1249 let syntax = ast.syntax().owned();
1250 ItemListNode(syntax)
1251 }
1252} 1328}
1253#[derive(Debug, Clone, Copy)] 1329impl<R: TreeRoot<RaTypes>> Eq for ItemListNode<R> {}
1254pub struct ItemList<'a> { 1330impl<R: TreeRoot<RaTypes>> Hash for ItemListNode<R> {
1255 syntax: SyntaxNodeRef<'a>, 1331 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1256} 1332}
1257 1333
1258impl<'a> AstNode<'a> for ItemList<'a> { 1334impl<'a> AstNode<'a> for ItemList<'a> {
@@ -1265,30 +1341,33 @@ impl<'a> AstNode<'a> for ItemList<'a> {
1265 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1341 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1266} 1342}
1267 1343
1344impl<R: TreeRoot<RaTypes>> ItemListNode<R> {
1345 pub fn borrowed(&self) -> ItemList {
1346 ItemListNode { syntax: self.syntax.borrowed() }
1347 }
1348 pub fn owned(&self) -> ItemListNode {
1349 ItemListNode { syntax: self.syntax.owned() }
1350 }
1351}
1352
1353
1268impl<'a> ast::FnDefOwner<'a> for ItemList<'a> {} 1354impl<'a> ast::FnDefOwner<'a> for ItemList<'a> {}
1269impl<'a> ast::ModuleItemOwner<'a> for ItemList<'a> {} 1355impl<'a> ast::ModuleItemOwner<'a> for ItemList<'a> {}
1270impl<'a> ItemList<'a> {} 1356impl<'a> ItemList<'a> {}
1271 1357
1272// Label 1358// Label
1273 1359#[derive(Debug, Clone, Copy,)]
1274#[derive(Debug, Clone)] 1360pub struct LabelNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1275pub struct LabelNode(SyntaxNode); 1361 pub(crate) syntax: SyntaxNode<R>,
1276
1277impl LabelNode {
1278 pub fn ast(&self) -> Label {
1279 Label::cast(self.0.borrowed()).unwrap()
1280 }
1281} 1362}
1363pub type Label<'a> = LabelNode<RefRoot<'a>>;
1282 1364
1283impl<'a> From<Label<'a>> for LabelNode { 1365impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LabelNode<R1>> for LabelNode<R2> {
1284 fn from(ast: Label<'a>) -> LabelNode { 1366 fn eq(&self, other: &LabelNode<R1>) -> bool { self.syntax == other.syntax }
1285 let syntax = ast.syntax().owned();
1286 LabelNode(syntax)
1287 }
1288} 1367}
1289#[derive(Debug, Clone, Copy)] 1368impl<R: TreeRoot<RaTypes>> Eq for LabelNode<R> {}
1290pub struct Label<'a> { 1369impl<R: TreeRoot<RaTypes>> Hash for LabelNode<R> {
1291 syntax: SyntaxNodeRef<'a>, 1370 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1292} 1371}
1293 1372
1294impl<'a> AstNode<'a> for Label<'a> { 1373impl<'a> AstNode<'a> for Label<'a> {
@@ -1301,28 +1380,31 @@ impl<'a> AstNode<'a> for Label<'a> {
1301 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1380 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1302} 1381}
1303 1382
1304impl<'a> Label<'a> {} 1383impl<R: TreeRoot<RaTypes>> LabelNode<R> {
1384 pub fn borrowed(&self) -> Label {
1385 LabelNode { syntax: self.syntax.borrowed() }
1386 }
1387 pub fn owned(&self) -> LabelNode {
1388 LabelNode { syntax: self.syntax.owned() }
1389 }
1390}
1305 1391
1306// LambdaExpr
1307 1392
1308#[derive(Debug, Clone)] 1393impl<'a> Label<'a> {}
1309pub struct LambdaExprNode(SyntaxNode);
1310 1394
1311impl LambdaExprNode { 1395// LambdaExpr
1312 pub fn ast(&self) -> LambdaExpr { 1396#[derive(Debug, Clone, Copy,)]
1313 LambdaExpr::cast(self.0.borrowed()).unwrap() 1397pub struct LambdaExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1314 } 1398 pub(crate) syntax: SyntaxNode<R>,
1315} 1399}
1400pub type LambdaExpr<'a> = LambdaExprNode<RefRoot<'a>>;
1316 1401
1317impl<'a> From<LambdaExpr<'a>> for LambdaExprNode { 1402impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LambdaExprNode<R1>> for LambdaExprNode<R2> {
1318 fn from(ast: LambdaExpr<'a>) -> LambdaExprNode { 1403 fn eq(&self, other: &LambdaExprNode<R1>) -> bool { self.syntax == other.syntax }
1319 let syntax = ast.syntax().owned();
1320 LambdaExprNode(syntax)
1321 }
1322} 1404}
1323#[derive(Debug, Clone, Copy)] 1405impl<R: TreeRoot<RaTypes>> Eq for LambdaExprNode<R> {}
1324pub struct LambdaExpr<'a> { 1406impl<R: TreeRoot<RaTypes>> Hash for LambdaExprNode<R> {
1325 syntax: SyntaxNodeRef<'a>, 1407 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1326} 1408}
1327 1409
1328impl<'a> AstNode<'a> for LambdaExpr<'a> { 1410impl<'a> AstNode<'a> for LambdaExpr<'a> {
@@ -1335,6 +1417,16 @@ impl<'a> AstNode<'a> for LambdaExpr<'a> {
1335 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1417 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1336} 1418}
1337 1419
1420impl<R: TreeRoot<RaTypes>> LambdaExprNode<R> {
1421 pub fn borrowed(&self) -> LambdaExpr {
1422 LambdaExprNode { syntax: self.syntax.borrowed() }
1423 }
1424 pub fn owned(&self) -> LambdaExprNode {
1425 LambdaExprNode { syntax: self.syntax.owned() }
1426 }
1427}
1428
1429
1338impl<'a> LambdaExpr<'a> { 1430impl<'a> LambdaExpr<'a> {
1339 pub fn param_list(self) -> Option<ParamList<'a>> { 1431 pub fn param_list(self) -> Option<ParamList<'a>> {
1340 super::child_opt(self) 1432 super::child_opt(self)
@@ -1346,25 +1438,18 @@ impl<'a> LambdaExpr<'a> {
1346} 1438}
1347 1439
1348// LetStmt 1440// LetStmt
1349 1441#[derive(Debug, Clone, Copy,)]
1350#[derive(Debug, Clone)] 1442pub struct LetStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1351pub struct LetStmtNode(SyntaxNode); 1443 pub(crate) syntax: SyntaxNode<R>,
1352
1353impl LetStmtNode {
1354 pub fn ast(&self) -> LetStmt {
1355 LetStmt::cast(self.0.borrowed()).unwrap()
1356 }
1357} 1444}
1445pub type LetStmt<'a> = LetStmtNode<RefRoot<'a>>;
1358 1446
1359impl<'a> From<LetStmt<'a>> for LetStmtNode { 1447impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LetStmtNode<R1>> for LetStmtNode<R2> {
1360 fn from(ast: LetStmt<'a>) -> LetStmtNode { 1448 fn eq(&self, other: &LetStmtNode<R1>) -> bool { self.syntax == other.syntax }
1361 let syntax = ast.syntax().owned();
1362 LetStmtNode(syntax)
1363 }
1364} 1449}
1365#[derive(Debug, Clone, Copy)] 1450impl<R: TreeRoot<RaTypes>> Eq for LetStmtNode<R> {}
1366pub struct LetStmt<'a> { 1451impl<R: TreeRoot<RaTypes>> Hash for LetStmtNode<R> {
1367 syntax: SyntaxNodeRef<'a>, 1452 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1368} 1453}
1369 1454
1370impl<'a> AstNode<'a> for LetStmt<'a> { 1455impl<'a> AstNode<'a> for LetStmt<'a> {
@@ -1377,6 +1462,16 @@ impl<'a> AstNode<'a> for LetStmt<'a> {
1377 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1462 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1378} 1463}
1379 1464
1465impl<R: TreeRoot<RaTypes>> LetStmtNode<R> {
1466 pub fn borrowed(&self) -> LetStmt {
1467 LetStmtNode { syntax: self.syntax.borrowed() }
1468 }
1469 pub fn owned(&self) -> LetStmtNode {
1470 LetStmtNode { syntax: self.syntax.owned() }
1471 }
1472}
1473
1474
1380impl<'a> LetStmt<'a> { 1475impl<'a> LetStmt<'a> {
1381 pub fn pat(self) -> Option<Pat<'a>> { 1476 pub fn pat(self) -> Option<Pat<'a>> {
1382 super::child_opt(self) 1477 super::child_opt(self)
@@ -1388,25 +1483,18 @@ impl<'a> LetStmt<'a> {
1388} 1483}
1389 1484
1390// Lifetime 1485// Lifetime
1391 1486#[derive(Debug, Clone, Copy,)]
1392#[derive(Debug, Clone)] 1487pub struct LifetimeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1393pub struct LifetimeNode(SyntaxNode); 1488 pub(crate) syntax: SyntaxNode<R>,
1394
1395impl LifetimeNode {
1396 pub fn ast(&self) -> Lifetime {
1397 Lifetime::cast(self.0.borrowed()).unwrap()
1398 }
1399} 1489}
1490pub type Lifetime<'a> = LifetimeNode<RefRoot<'a>>;
1400 1491
1401impl<'a> From<Lifetime<'a>> for LifetimeNode { 1492impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeNode<R1>> for LifetimeNode<R2> {
1402 fn from(ast: Lifetime<'a>) -> LifetimeNode { 1493 fn eq(&self, other: &LifetimeNode<R1>) -> bool { self.syntax == other.syntax }
1403 let syntax = ast.syntax().owned();
1404 LifetimeNode(syntax)
1405 }
1406} 1494}
1407#[derive(Debug, Clone, Copy)] 1495impl<R: TreeRoot<RaTypes>> Eq for LifetimeNode<R> {}
1408pub struct Lifetime<'a> { 1496impl<R: TreeRoot<RaTypes>> Hash for LifetimeNode<R> {
1409 syntax: SyntaxNodeRef<'a>, 1497 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1410} 1498}
1411 1499
1412impl<'a> AstNode<'a> for Lifetime<'a> { 1500impl<'a> AstNode<'a> for Lifetime<'a> {
@@ -1419,28 +1507,31 @@ impl<'a> AstNode<'a> for Lifetime<'a> {
1419 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1507 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1420} 1508}
1421 1509
1422impl<'a> Lifetime<'a> {} 1510impl<R: TreeRoot<RaTypes>> LifetimeNode<R> {
1511 pub fn borrowed(&self) -> Lifetime {
1512 LifetimeNode { syntax: self.syntax.borrowed() }
1513 }
1514 pub fn owned(&self) -> LifetimeNode {
1515 LifetimeNode { syntax: self.syntax.owned() }
1516 }
1517}
1423 1518
1424// LifetimeParam
1425 1519
1426#[derive(Debug, Clone)] 1520impl<'a> Lifetime<'a> {}
1427pub struct LifetimeParamNode(SyntaxNode);
1428 1521
1429impl LifetimeParamNode { 1522// LifetimeParam
1430 pub fn ast(&self) -> LifetimeParam { 1523#[derive(Debug, Clone, Copy,)]
1431 LifetimeParam::cast(self.0.borrowed()).unwrap() 1524pub struct LifetimeParamNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1432 } 1525 pub(crate) syntax: SyntaxNode<R>,
1433} 1526}
1527pub type LifetimeParam<'a> = LifetimeParamNode<RefRoot<'a>>;
1434 1528
1435impl<'a> From<LifetimeParam<'a>> for LifetimeParamNode { 1529impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeParamNode<R1>> for LifetimeParamNode<R2> {
1436 fn from(ast: LifetimeParam<'a>) -> LifetimeParamNode { 1530 fn eq(&self, other: &LifetimeParamNode<R1>) -> bool { self.syntax == other.syntax }
1437 let syntax = ast.syntax().owned();
1438 LifetimeParamNode(syntax)
1439 }
1440} 1531}
1441#[derive(Debug, Clone, Copy)] 1532impl<R: TreeRoot<RaTypes>> Eq for LifetimeParamNode<R> {}
1442pub struct LifetimeParam<'a> { 1533impl<R: TreeRoot<RaTypes>> Hash for LifetimeParamNode<R> {
1443 syntax: SyntaxNodeRef<'a>, 1534 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1444} 1535}
1445 1536
1446impl<'a> AstNode<'a> for LifetimeParam<'a> { 1537impl<'a> AstNode<'a> for LifetimeParam<'a> {
@@ -1453,6 +1544,16 @@ impl<'a> AstNode<'a> for LifetimeParam<'a> {
1453 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1544 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1454} 1545}
1455 1546
1547impl<R: TreeRoot<RaTypes>> LifetimeParamNode<R> {
1548 pub fn borrowed(&self) -> LifetimeParam {
1549 LifetimeParamNode { syntax: self.syntax.borrowed() }
1550 }
1551 pub fn owned(&self) -> LifetimeParamNode {
1552 LifetimeParamNode { syntax: self.syntax.owned() }
1553 }
1554}
1555
1556
1456impl<'a> LifetimeParam<'a> { 1557impl<'a> LifetimeParam<'a> {
1457 pub fn lifetime(self) -> Option<Lifetime<'a>> { 1558 pub fn lifetime(self) -> Option<Lifetime<'a>> {
1458 super::child_opt(self) 1559 super::child_opt(self)
@@ -1460,25 +1561,18 @@ impl<'a> LifetimeParam<'a> {
1460} 1561}
1461 1562
1462// Literal 1563// Literal
1463 1564#[derive(Debug, Clone, Copy,)]
1464#[derive(Debug, Clone)] 1565pub struct LiteralNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1465pub struct LiteralNode(SyntaxNode); 1566 pub(crate) syntax: SyntaxNode<R>,
1466
1467impl LiteralNode {
1468 pub fn ast(&self) -> Literal {
1469 Literal::cast(self.0.borrowed()).unwrap()
1470 }
1471} 1567}
1568pub type Literal<'a> = LiteralNode<RefRoot<'a>>;
1472 1569
1473impl<'a> From<Literal<'a>> for LiteralNode { 1570impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LiteralNode<R1>> for LiteralNode<R2> {
1474 fn from(ast: Literal<'a>) -> LiteralNode { 1571 fn eq(&self, other: &LiteralNode<R1>) -> bool { self.syntax == other.syntax }
1475 let syntax = ast.syntax().owned();
1476 LiteralNode(syntax)
1477 }
1478} 1572}
1479#[derive(Debug, Clone, Copy)] 1573impl<R: TreeRoot<RaTypes>> Eq for LiteralNode<R> {}
1480pub struct Literal<'a> { 1574impl<R: TreeRoot<RaTypes>> Hash for LiteralNode<R> {
1481 syntax: SyntaxNodeRef<'a>, 1575 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1482} 1576}
1483 1577
1484impl<'a> AstNode<'a> for Literal<'a> { 1578impl<'a> AstNode<'a> for Literal<'a> {
@@ -1491,28 +1585,31 @@ impl<'a> AstNode<'a> for Literal<'a> {
1491 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1585 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1492} 1586}
1493 1587
1494impl<'a> Literal<'a> {} 1588impl<R: TreeRoot<RaTypes>> LiteralNode<R> {
1589 pub fn borrowed(&self) -> Literal {
1590 LiteralNode { syntax: self.syntax.borrowed() }
1591 }
1592 pub fn owned(&self) -> LiteralNode {
1593 LiteralNode { syntax: self.syntax.owned() }
1594 }
1595}
1495 1596
1496// LoopExpr
1497 1597
1498#[derive(Debug, Clone)] 1598impl<'a> Literal<'a> {}
1499pub struct LoopExprNode(SyntaxNode);
1500 1599
1501impl LoopExprNode { 1600// LoopExpr
1502 pub fn ast(&self) -> LoopExpr { 1601#[derive(Debug, Clone, Copy,)]
1503 LoopExpr::cast(self.0.borrowed()).unwrap() 1602pub struct LoopExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1504 } 1603 pub(crate) syntax: SyntaxNode<R>,
1505} 1604}
1605pub type LoopExpr<'a> = LoopExprNode<RefRoot<'a>>;
1506 1606
1507impl<'a> From<LoopExpr<'a>> for LoopExprNode { 1607impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LoopExprNode<R1>> for LoopExprNode<R2> {
1508 fn from(ast: LoopExpr<'a>) -> LoopExprNode { 1608 fn eq(&self, other: &LoopExprNode<R1>) -> bool { self.syntax == other.syntax }
1509 let syntax = ast.syntax().owned();
1510 LoopExprNode(syntax)
1511 }
1512} 1609}
1513#[derive(Debug, Clone, Copy)] 1610impl<R: TreeRoot<RaTypes>> Eq for LoopExprNode<R> {}
1514pub struct LoopExpr<'a> { 1611impl<R: TreeRoot<RaTypes>> Hash for LoopExprNode<R> {
1515 syntax: SyntaxNodeRef<'a>, 1612 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1516} 1613}
1517 1614
1518impl<'a> AstNode<'a> for LoopExpr<'a> { 1615impl<'a> AstNode<'a> for LoopExpr<'a> {
@@ -1525,29 +1622,32 @@ impl<'a> AstNode<'a> for LoopExpr<'a> {
1525 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1622 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1526} 1623}
1527 1624
1625impl<R: TreeRoot<RaTypes>> LoopExprNode<R> {
1626 pub fn borrowed(&self) -> LoopExpr {
1627 LoopExprNode { syntax: self.syntax.borrowed() }
1628 }
1629 pub fn owned(&self) -> LoopExprNode {
1630 LoopExprNode { syntax: self.syntax.owned() }
1631 }
1632}
1633
1634
1528impl<'a> ast::LoopBodyOwner<'a> for LoopExpr<'a> {} 1635impl<'a> ast::LoopBodyOwner<'a> for LoopExpr<'a> {}
1529impl<'a> LoopExpr<'a> {} 1636impl<'a> LoopExpr<'a> {}
1530 1637
1531// MatchArm 1638// MatchArm
1532 1639#[derive(Debug, Clone, Copy,)]
1533#[derive(Debug, Clone)] 1640pub struct MatchArmNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1534pub struct MatchArmNode(SyntaxNode); 1641 pub(crate) syntax: SyntaxNode<R>,
1535
1536impl MatchArmNode {
1537 pub fn ast(&self) -> MatchArm {
1538 MatchArm::cast(self.0.borrowed()).unwrap()
1539 }
1540} 1642}
1643pub type MatchArm<'a> = MatchArmNode<RefRoot<'a>>;
1541 1644
1542impl<'a> From<MatchArm<'a>> for MatchArmNode { 1645impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmNode<R1>> for MatchArmNode<R2> {
1543 fn from(ast: MatchArm<'a>) -> MatchArmNode { 1646 fn eq(&self, other: &MatchArmNode<R1>) -> bool { self.syntax == other.syntax }
1544 let syntax = ast.syntax().owned();
1545 MatchArmNode(syntax)
1546 }
1547} 1647}
1548#[derive(Debug, Clone, Copy)] 1648impl<R: TreeRoot<RaTypes>> Eq for MatchArmNode<R> {}
1549pub struct MatchArm<'a> { 1649impl<R: TreeRoot<RaTypes>> Hash for MatchArmNode<R> {
1550 syntax: SyntaxNodeRef<'a>, 1650 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1551} 1651}
1552 1652
1553impl<'a> AstNode<'a> for MatchArm<'a> { 1653impl<'a> AstNode<'a> for MatchArm<'a> {
@@ -1560,6 +1660,16 @@ impl<'a> AstNode<'a> for MatchArm<'a> {
1560 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1660 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1561} 1661}
1562 1662
1663impl<R: TreeRoot<RaTypes>> MatchArmNode<R> {
1664 pub fn borrowed(&self) -> MatchArm {
1665 MatchArmNode { syntax: self.syntax.borrowed() }
1666 }
1667 pub fn owned(&self) -> MatchArmNode {
1668 MatchArmNode { syntax: self.syntax.owned() }
1669 }
1670}
1671
1672
1563impl<'a> MatchArm<'a> { 1673impl<'a> MatchArm<'a> {
1564 pub fn pats(self) -> impl Iterator<Item = Pat<'a>> + 'a { 1674 pub fn pats(self) -> impl Iterator<Item = Pat<'a>> + 'a {
1565 super::children(self) 1675 super::children(self)
@@ -1575,25 +1685,18 @@ impl<'a> MatchArm<'a> {
1575} 1685}
1576 1686
1577// MatchArmList 1687// MatchArmList
1578 1688#[derive(Debug, Clone, Copy,)]
1579#[derive(Debug, Clone)] 1689pub struct MatchArmListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1580pub struct MatchArmListNode(SyntaxNode); 1690 pub(crate) syntax: SyntaxNode<R>,
1581
1582impl MatchArmListNode {
1583 pub fn ast(&self) -> MatchArmList {
1584 MatchArmList::cast(self.0.borrowed()).unwrap()
1585 }
1586} 1691}
1692pub type MatchArmList<'a> = MatchArmListNode<RefRoot<'a>>;
1587 1693
1588impl<'a> From<MatchArmList<'a>> for MatchArmListNode { 1694impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmListNode<R1>> for MatchArmListNode<R2> {
1589 fn from(ast: MatchArmList<'a>) -> MatchArmListNode { 1695 fn eq(&self, other: &MatchArmListNode<R1>) -> bool { self.syntax == other.syntax }
1590 let syntax = ast.syntax().owned();
1591 MatchArmListNode(syntax)
1592 }
1593} 1696}
1594#[derive(Debug, Clone, Copy)] 1697impl<R: TreeRoot<RaTypes>> Eq for MatchArmListNode<R> {}
1595pub struct MatchArmList<'a> { 1698impl<R: TreeRoot<RaTypes>> Hash for MatchArmListNode<R> {
1596 syntax: SyntaxNodeRef<'a>, 1699 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1597} 1700}
1598 1701
1599impl<'a> AstNode<'a> for MatchArmList<'a> { 1702impl<'a> AstNode<'a> for MatchArmList<'a> {
@@ -1606,6 +1709,16 @@ impl<'a> AstNode<'a> for MatchArmList<'a> {
1606 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1709 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1607} 1710}
1608 1711
1712impl<R: TreeRoot<RaTypes>> MatchArmListNode<R> {
1713 pub fn borrowed(&self) -> MatchArmList {
1714 MatchArmListNode { syntax: self.syntax.borrowed() }
1715 }
1716 pub fn owned(&self) -> MatchArmListNode {
1717 MatchArmListNode { syntax: self.syntax.owned() }
1718 }
1719}
1720
1721
1609impl<'a> MatchArmList<'a> { 1722impl<'a> MatchArmList<'a> {
1610 pub fn arms(self) -> impl Iterator<Item = MatchArm<'a>> + 'a { 1723 pub fn arms(self) -> impl Iterator<Item = MatchArm<'a>> + 'a {
1611 super::children(self) 1724 super::children(self)
@@ -1613,25 +1726,18 @@ impl<'a> MatchArmList<'a> {
1613} 1726}
1614 1727
1615// MatchExpr 1728// MatchExpr
1616 1729#[derive(Debug, Clone, Copy,)]
1617#[derive(Debug, Clone)] 1730pub struct MatchExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1618pub struct MatchExprNode(SyntaxNode); 1731 pub(crate) syntax: SyntaxNode<R>,
1619
1620impl MatchExprNode {
1621 pub fn ast(&self) -> MatchExpr {
1622 MatchExpr::cast(self.0.borrowed()).unwrap()
1623 }
1624} 1732}
1733pub type MatchExpr<'a> = MatchExprNode<RefRoot<'a>>;
1625 1734
1626impl<'a> From<MatchExpr<'a>> for MatchExprNode { 1735impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchExprNode<R1>> for MatchExprNode<R2> {
1627 fn from(ast: MatchExpr<'a>) -> MatchExprNode { 1736 fn eq(&self, other: &MatchExprNode<R1>) -> bool { self.syntax == other.syntax }
1628 let syntax = ast.syntax().owned();
1629 MatchExprNode(syntax)
1630 }
1631} 1737}
1632#[derive(Debug, Clone, Copy)] 1738impl<R: TreeRoot<RaTypes>> Eq for MatchExprNode<R> {}
1633pub struct MatchExpr<'a> { 1739impl<R: TreeRoot<RaTypes>> Hash for MatchExprNode<R> {
1634 syntax: SyntaxNodeRef<'a>, 1740 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1635} 1741}
1636 1742
1637impl<'a> AstNode<'a> for MatchExpr<'a> { 1743impl<'a> AstNode<'a> for MatchExpr<'a> {
@@ -1644,6 +1750,16 @@ impl<'a> AstNode<'a> for MatchExpr<'a> {
1644 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1750 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1645} 1751}
1646 1752
1753impl<R: TreeRoot<RaTypes>> MatchExprNode<R> {
1754 pub fn borrowed(&self) -> MatchExpr {
1755 MatchExprNode { syntax: self.syntax.borrowed() }
1756 }
1757 pub fn owned(&self) -> MatchExprNode {
1758 MatchExprNode { syntax: self.syntax.owned() }
1759 }
1760}
1761
1762
1647impl<'a> MatchExpr<'a> { 1763impl<'a> MatchExpr<'a> {
1648 pub fn expr(self) -> Option<Expr<'a>> { 1764 pub fn expr(self) -> Option<Expr<'a>> {
1649 super::child_opt(self) 1765 super::child_opt(self)
@@ -1655,25 +1771,18 @@ impl<'a> MatchExpr<'a> {
1655} 1771}
1656 1772
1657// MatchGuard 1773// MatchGuard
1658 1774#[derive(Debug, Clone, Copy,)]
1659#[derive(Debug, Clone)] 1775pub struct MatchGuardNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1660pub struct MatchGuardNode(SyntaxNode); 1776 pub(crate) syntax: SyntaxNode<R>,
1661
1662impl MatchGuardNode {
1663 pub fn ast(&self) -> MatchGuard {
1664 MatchGuard::cast(self.0.borrowed()).unwrap()
1665 }
1666} 1777}
1778pub type MatchGuard<'a> = MatchGuardNode<RefRoot<'a>>;
1667 1779
1668impl<'a> From<MatchGuard<'a>> for MatchGuardNode { 1780impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchGuardNode<R1>> for MatchGuardNode<R2> {
1669 fn from(ast: MatchGuard<'a>) -> MatchGuardNode { 1781 fn eq(&self, other: &MatchGuardNode<R1>) -> bool { self.syntax == other.syntax }
1670 let syntax = ast.syntax().owned();
1671 MatchGuardNode(syntax)
1672 }
1673} 1782}
1674#[derive(Debug, Clone, Copy)] 1783impl<R: TreeRoot<RaTypes>> Eq for MatchGuardNode<R> {}
1675pub struct MatchGuard<'a> { 1784impl<R: TreeRoot<RaTypes>> Hash for MatchGuardNode<R> {
1676 syntax: SyntaxNodeRef<'a>, 1785 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1677} 1786}
1678 1787
1679impl<'a> AstNode<'a> for MatchGuard<'a> { 1788impl<'a> AstNode<'a> for MatchGuard<'a> {
@@ -1686,28 +1795,31 @@ impl<'a> AstNode<'a> for MatchGuard<'a> {
1686 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1795 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1687} 1796}
1688 1797
1689impl<'a> MatchGuard<'a> {} 1798impl<R: TreeRoot<RaTypes>> MatchGuardNode<R> {
1799 pub fn borrowed(&self) -> MatchGuard {
1800 MatchGuardNode { syntax: self.syntax.borrowed() }
1801 }
1802 pub fn owned(&self) -> MatchGuardNode {
1803 MatchGuardNode { syntax: self.syntax.owned() }
1804 }
1805}
1690 1806
1691// MethodCallExpr
1692 1807
1693#[derive(Debug, Clone)] 1808impl<'a> MatchGuard<'a> {}
1694pub struct MethodCallExprNode(SyntaxNode);
1695 1809
1696impl MethodCallExprNode { 1810// MethodCallExpr
1697 pub fn ast(&self) -> MethodCallExpr { 1811#[derive(Debug, Clone, Copy,)]
1698 MethodCallExpr::cast(self.0.borrowed()).unwrap() 1812pub struct MethodCallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1699 } 1813 pub(crate) syntax: SyntaxNode<R>,
1700} 1814}
1815pub type MethodCallExpr<'a> = MethodCallExprNode<RefRoot<'a>>;
1701 1816
1702impl<'a> From<MethodCallExpr<'a>> for MethodCallExprNode { 1817impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MethodCallExprNode<R1>> for MethodCallExprNode<R2> {
1703 fn from(ast: MethodCallExpr<'a>) -> MethodCallExprNode { 1818 fn eq(&self, other: &MethodCallExprNode<R1>) -> bool { self.syntax == other.syntax }
1704 let syntax = ast.syntax().owned();
1705 MethodCallExprNode(syntax)
1706 }
1707} 1819}
1708#[derive(Debug, Clone, Copy)] 1820impl<R: TreeRoot<RaTypes>> Eq for MethodCallExprNode<R> {}
1709pub struct MethodCallExpr<'a> { 1821impl<R: TreeRoot<RaTypes>> Hash for MethodCallExprNode<R> {
1710 syntax: SyntaxNodeRef<'a>, 1822 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1711} 1823}
1712 1824
1713impl<'a> AstNode<'a> for MethodCallExpr<'a> { 1825impl<'a> AstNode<'a> for MethodCallExpr<'a> {
@@ -1720,6 +1832,16 @@ impl<'a> AstNode<'a> for MethodCallExpr<'a> {
1720 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1832 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1721} 1833}
1722 1834
1835impl<R: TreeRoot<RaTypes>> MethodCallExprNode<R> {
1836 pub fn borrowed(&self) -> MethodCallExpr {
1837 MethodCallExprNode { syntax: self.syntax.borrowed() }
1838 }
1839 pub fn owned(&self) -> MethodCallExprNode {
1840 MethodCallExprNode { syntax: self.syntax.owned() }
1841 }
1842}
1843
1844
1723impl<'a> ast::ArgListOwner<'a> for MethodCallExpr<'a> {} 1845impl<'a> ast::ArgListOwner<'a> for MethodCallExpr<'a> {}
1724impl<'a> MethodCallExpr<'a> { 1846impl<'a> MethodCallExpr<'a> {
1725 pub fn expr(self) -> Option<Expr<'a>> { 1847 pub fn expr(self) -> Option<Expr<'a>> {
@@ -1728,25 +1850,18 @@ impl<'a> MethodCallExpr<'a> {
1728} 1850}
1729 1851
1730// Module 1852// Module
1731 1853#[derive(Debug, Clone, Copy,)]
1732#[derive(Debug, Clone)] 1854pub struct ModuleNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1733pub struct ModuleNode(SyntaxNode); 1855 pub(crate) syntax: SyntaxNode<R>,
1734
1735impl ModuleNode {
1736 pub fn ast(&self) -> Module {
1737 Module::cast(self.0.borrowed()).unwrap()
1738 }
1739} 1856}
1857pub type Module<'a> = ModuleNode<RefRoot<'a>>;
1740 1858
1741impl<'a> From<Module<'a>> for ModuleNode { 1859impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ModuleNode<R1>> for ModuleNode<R2> {
1742 fn from(ast: Module<'a>) -> ModuleNode { 1860 fn eq(&self, other: &ModuleNode<R1>) -> bool { self.syntax == other.syntax }
1743 let syntax = ast.syntax().owned();
1744 ModuleNode(syntax)
1745 }
1746} 1861}
1747#[derive(Debug, Clone, Copy)] 1862impl<R: TreeRoot<RaTypes>> Eq for ModuleNode<R> {}
1748pub struct Module<'a> { 1863impl<R: TreeRoot<RaTypes>> Hash for ModuleNode<R> {
1749 syntax: SyntaxNodeRef<'a>, 1864 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1750} 1865}
1751 1866
1752impl<'a> AstNode<'a> for Module<'a> { 1867impl<'a> AstNode<'a> for Module<'a> {
@@ -1759,6 +1874,16 @@ impl<'a> AstNode<'a> for Module<'a> {
1759 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1874 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1760} 1875}
1761 1876
1877impl<R: TreeRoot<RaTypes>> ModuleNode<R> {
1878 pub fn borrowed(&self) -> Module {
1879 ModuleNode { syntax: self.syntax.borrowed() }
1880 }
1881 pub fn owned(&self) -> ModuleNode {
1882 ModuleNode { syntax: self.syntax.owned() }
1883 }
1884}
1885
1886
1762impl<'a> ast::NameOwner<'a> for Module<'a> {} 1887impl<'a> ast::NameOwner<'a> for Module<'a> {}
1763impl<'a> ast::AttrsOwner<'a> for Module<'a> {} 1888impl<'a> ast::AttrsOwner<'a> for Module<'a> {}
1764impl<'a> Module<'a> { 1889impl<'a> Module<'a> {
@@ -1768,23 +1893,7 @@ impl<'a> Module<'a> {
1768} 1893}
1769 1894
1770// ModuleItem 1895// ModuleItem
1771 1896#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1772#[derive(Debug, Clone)]
1773pub struct ModuleItemNode(SyntaxNode);
1774
1775impl ModuleItemNode {
1776 pub fn ast(&self) -> ModuleItem {
1777 ModuleItem::cast(self.0.borrowed()).unwrap()
1778 }
1779}
1780
1781impl<'a> From<ModuleItem<'a>> for ModuleItemNode {
1782 fn from(ast: ModuleItem<'a>) -> ModuleItemNode {
1783 let syntax = ast.syntax().owned();
1784 ModuleItemNode(syntax)
1785 }
1786}
1787#[derive(Debug, Clone, Copy)]
1788pub enum ModuleItem<'a> { 1897pub enum ModuleItem<'a> {
1789 StructDef(StructDef<'a>), 1898 StructDef(StructDef<'a>),
1790 EnumDef(EnumDef<'a>), 1899 EnumDef(EnumDef<'a>),
@@ -1836,25 +1945,18 @@ impl<'a> AstNode<'a> for ModuleItem<'a> {
1836impl<'a> ModuleItem<'a> {} 1945impl<'a> ModuleItem<'a> {}
1837 1946
1838// Name 1947// Name
1839 1948#[derive(Debug, Clone, Copy,)]
1840#[derive(Debug, Clone)] 1949pub struct NameNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1841pub struct NameNode(SyntaxNode); 1950 pub(crate) syntax: SyntaxNode<R>,
1842
1843impl NameNode {
1844 pub fn ast(&self) -> Name {
1845 Name::cast(self.0.borrowed()).unwrap()
1846 }
1847} 1951}
1952pub type Name<'a> = NameNode<RefRoot<'a>>;
1848 1953
1849impl<'a> From<Name<'a>> for NameNode { 1954impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameNode<R1>> for NameNode<R2> {
1850 fn from(ast: Name<'a>) -> NameNode { 1955 fn eq(&self, other: &NameNode<R1>) -> bool { self.syntax == other.syntax }
1851 let syntax = ast.syntax().owned();
1852 NameNode(syntax)
1853 }
1854} 1956}
1855#[derive(Debug, Clone, Copy)] 1957impl<R: TreeRoot<RaTypes>> Eq for NameNode<R> {}
1856pub struct Name<'a> { 1958impl<R: TreeRoot<RaTypes>> Hash for NameNode<R> {
1857 syntax: SyntaxNodeRef<'a>, 1959 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1858} 1960}
1859 1961
1860impl<'a> AstNode<'a> for Name<'a> { 1962impl<'a> AstNode<'a> for Name<'a> {
@@ -1867,28 +1969,31 @@ impl<'a> AstNode<'a> for Name<'a> {
1867 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 1969 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1868} 1970}
1869 1971
1870impl<'a> Name<'a> {} 1972impl<R: TreeRoot<RaTypes>> NameNode<R> {
1973 pub fn borrowed(&self) -> Name {
1974 NameNode { syntax: self.syntax.borrowed() }
1975 }
1976 pub fn owned(&self) -> NameNode {
1977 NameNode { syntax: self.syntax.owned() }
1978 }
1979}
1871 1980
1872// NameRef
1873 1981
1874#[derive(Debug, Clone)] 1982impl<'a> Name<'a> {}
1875pub struct NameRefNode(SyntaxNode);
1876 1983
1877impl NameRefNode { 1984// NameRef
1878 pub fn ast(&self) -> NameRef { 1985#[derive(Debug, Clone, Copy,)]
1879 NameRef::cast(self.0.borrowed()).unwrap() 1986pub struct NameRefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1880 } 1987 pub(crate) syntax: SyntaxNode<R>,
1881} 1988}
1989pub type NameRef<'a> = NameRefNode<RefRoot<'a>>;
1882 1990
1883impl<'a> From<NameRef<'a>> for NameRefNode { 1991impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameRefNode<R1>> for NameRefNode<R2> {
1884 fn from(ast: NameRef<'a>) -> NameRefNode { 1992 fn eq(&self, other: &NameRefNode<R1>) -> bool { self.syntax == other.syntax }
1885 let syntax = ast.syntax().owned();
1886 NameRefNode(syntax)
1887 }
1888} 1993}
1889#[derive(Debug, Clone, Copy)] 1994impl<R: TreeRoot<RaTypes>> Eq for NameRefNode<R> {}
1890pub struct NameRef<'a> { 1995impl<R: TreeRoot<RaTypes>> Hash for NameRefNode<R> {
1891 syntax: SyntaxNodeRef<'a>, 1996 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1892} 1997}
1893 1998
1894impl<'a> AstNode<'a> for NameRef<'a> { 1999impl<'a> AstNode<'a> for NameRef<'a> {
@@ -1901,28 +2006,31 @@ impl<'a> AstNode<'a> for NameRef<'a> {
1901 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2006 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1902} 2007}
1903 2008
1904impl<'a> NameRef<'a> {} 2009impl<R: TreeRoot<RaTypes>> NameRefNode<R> {
2010 pub fn borrowed(&self) -> NameRef {
2011 NameRefNode { syntax: self.syntax.borrowed() }
2012 }
2013 pub fn owned(&self) -> NameRefNode {
2014 NameRefNode { syntax: self.syntax.owned() }
2015 }
2016}
1905 2017
1906// NamedField
1907 2018
1908#[derive(Debug, Clone)] 2019impl<'a> NameRef<'a> {}
1909pub struct NamedFieldNode(SyntaxNode);
1910 2020
1911impl NamedFieldNode { 2021// NamedField
1912 pub fn ast(&self) -> NamedField { 2022#[derive(Debug, Clone, Copy,)]
1913 NamedField::cast(self.0.borrowed()).unwrap() 2023pub struct NamedFieldNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1914 } 2024 pub(crate) syntax: SyntaxNode<R>,
1915} 2025}
2026pub type NamedField<'a> = NamedFieldNode<RefRoot<'a>>;
1916 2027
1917impl<'a> From<NamedField<'a>> for NamedFieldNode { 2028impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldNode<R1>> for NamedFieldNode<R2> {
1918 fn from(ast: NamedField<'a>) -> NamedFieldNode { 2029 fn eq(&self, other: &NamedFieldNode<R1>) -> bool { self.syntax == other.syntax }
1919 let syntax = ast.syntax().owned();
1920 NamedFieldNode(syntax)
1921 }
1922} 2030}
1923#[derive(Debug, Clone, Copy)] 2031impl<R: TreeRoot<RaTypes>> Eq for NamedFieldNode<R> {}
1924pub struct NamedField<'a> { 2032impl<R: TreeRoot<RaTypes>> Hash for NamedFieldNode<R> {
1925 syntax: SyntaxNodeRef<'a>, 2033 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1926} 2034}
1927 2035
1928impl<'a> AstNode<'a> for NamedField<'a> { 2036impl<'a> AstNode<'a> for NamedField<'a> {
@@ -1935,28 +2043,31 @@ impl<'a> AstNode<'a> for NamedField<'a> {
1935 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2043 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1936} 2044}
1937 2045
1938impl<'a> NamedField<'a> {} 2046impl<R: TreeRoot<RaTypes>> NamedFieldNode<R> {
2047 pub fn borrowed(&self) -> NamedField {
2048 NamedFieldNode { syntax: self.syntax.borrowed() }
2049 }
2050 pub fn owned(&self) -> NamedFieldNode {
2051 NamedFieldNode { syntax: self.syntax.owned() }
2052 }
2053}
1939 2054
1940// NamedFieldDef
1941 2055
1942#[derive(Debug, Clone)] 2056impl<'a> NamedField<'a> {}
1943pub struct NamedFieldDefNode(SyntaxNode);
1944 2057
1945impl NamedFieldDefNode { 2058// NamedFieldDef
1946 pub fn ast(&self) -> NamedFieldDef { 2059#[derive(Debug, Clone, Copy,)]
1947 NamedFieldDef::cast(self.0.borrowed()).unwrap() 2060pub struct NamedFieldDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1948 } 2061 pub(crate) syntax: SyntaxNode<R>,
1949} 2062}
2063pub type NamedFieldDef<'a> = NamedFieldDefNode<RefRoot<'a>>;
1950 2064
1951impl<'a> From<NamedFieldDef<'a>> for NamedFieldDefNode { 2065impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldDefNode<R1>> for NamedFieldDefNode<R2> {
1952 fn from(ast: NamedFieldDef<'a>) -> NamedFieldDefNode { 2066 fn eq(&self, other: &NamedFieldDefNode<R1>) -> bool { self.syntax == other.syntax }
1953 let syntax = ast.syntax().owned();
1954 NamedFieldDefNode(syntax)
1955 }
1956} 2067}
1957#[derive(Debug, Clone, Copy)] 2068impl<R: TreeRoot<RaTypes>> Eq for NamedFieldDefNode<R> {}
1958pub struct NamedFieldDef<'a> { 2069impl<R: TreeRoot<RaTypes>> Hash for NamedFieldDefNode<R> {
1959 syntax: SyntaxNodeRef<'a>, 2070 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1960} 2071}
1961 2072
1962impl<'a> AstNode<'a> for NamedFieldDef<'a> { 2073impl<'a> AstNode<'a> for NamedFieldDef<'a> {
@@ -1969,30 +2080,33 @@ impl<'a> AstNode<'a> for NamedFieldDef<'a> {
1969 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2080 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
1970} 2081}
1971 2082
2083impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> {
2084 pub fn borrowed(&self) -> NamedFieldDef {
2085 NamedFieldDefNode { syntax: self.syntax.borrowed() }
2086 }
2087 pub fn owned(&self) -> NamedFieldDefNode {
2088 NamedFieldDefNode { syntax: self.syntax.owned() }
2089 }
2090}
2091
2092
1972impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {} 2093impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {}
1973impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {} 2094impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {}
1974impl<'a> NamedFieldDef<'a> {} 2095impl<'a> NamedFieldDef<'a> {}
1975 2096
1976// NamedFieldList 2097// NamedFieldList
1977 2098#[derive(Debug, Clone, Copy,)]
1978#[derive(Debug, Clone)] 2099pub struct NamedFieldListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
1979pub struct NamedFieldListNode(SyntaxNode); 2100 pub(crate) syntax: SyntaxNode<R>,
1980
1981impl NamedFieldListNode {
1982 pub fn ast(&self) -> NamedFieldList {
1983 NamedFieldList::cast(self.0.borrowed()).unwrap()
1984 }
1985} 2101}
2102pub type NamedFieldList<'a> = NamedFieldListNode<RefRoot<'a>>;
1986 2103
1987impl<'a> From<NamedFieldList<'a>> for NamedFieldListNode { 2104impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldListNode<R1>> for NamedFieldListNode<R2> {
1988 fn from(ast: NamedFieldList<'a>) -> NamedFieldListNode { 2105 fn eq(&self, other: &NamedFieldListNode<R1>) -> bool { self.syntax == other.syntax }
1989 let syntax = ast.syntax().owned();
1990 NamedFieldListNode(syntax)
1991 }
1992} 2106}
1993#[derive(Debug, Clone, Copy)] 2107impl<R: TreeRoot<RaTypes>> Eq for NamedFieldListNode<R> {}
1994pub struct NamedFieldList<'a> { 2108impl<R: TreeRoot<RaTypes>> Hash for NamedFieldListNode<R> {
1995 syntax: SyntaxNodeRef<'a>, 2109 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
1996} 2110}
1997 2111
1998impl<'a> AstNode<'a> for NamedFieldList<'a> { 2112impl<'a> AstNode<'a> for NamedFieldList<'a> {
@@ -2005,28 +2119,31 @@ impl<'a> AstNode<'a> for NamedFieldList<'a> {
2005 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2119 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2006} 2120}
2007 2121
2008impl<'a> NamedFieldList<'a> {} 2122impl<R: TreeRoot<RaTypes>> NamedFieldListNode<R> {
2123 pub fn borrowed(&self) -> NamedFieldList {
2124 NamedFieldListNode { syntax: self.syntax.borrowed() }
2125 }
2126 pub fn owned(&self) -> NamedFieldListNode {
2127 NamedFieldListNode { syntax: self.syntax.owned() }
2128 }
2129}
2009 2130
2010// NeverType
2011 2131
2012#[derive(Debug, Clone)] 2132impl<'a> NamedFieldList<'a> {}
2013pub struct NeverTypeNode(SyntaxNode);
2014 2133
2015impl NeverTypeNode { 2134// NeverType
2016 pub fn ast(&self) -> NeverType { 2135#[derive(Debug, Clone, Copy,)]
2017 NeverType::cast(self.0.borrowed()).unwrap() 2136pub struct NeverTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2018 } 2137 pub(crate) syntax: SyntaxNode<R>,
2019} 2138}
2139pub type NeverType<'a> = NeverTypeNode<RefRoot<'a>>;
2020 2140
2021impl<'a> From<NeverType<'a>> for NeverTypeNode { 2141impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NeverTypeNode<R1>> for NeverTypeNode<R2> {
2022 fn from(ast: NeverType<'a>) -> NeverTypeNode { 2142 fn eq(&self, other: &NeverTypeNode<R1>) -> bool { self.syntax == other.syntax }
2023 let syntax = ast.syntax().owned();
2024 NeverTypeNode(syntax)
2025 }
2026} 2143}
2027#[derive(Debug, Clone, Copy)] 2144impl<R: TreeRoot<RaTypes>> Eq for NeverTypeNode<R> {}
2028pub struct NeverType<'a> { 2145impl<R: TreeRoot<RaTypes>> Hash for NeverTypeNode<R> {
2029 syntax: SyntaxNodeRef<'a>, 2146 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2030} 2147}
2031 2148
2032impl<'a> AstNode<'a> for NeverType<'a> { 2149impl<'a> AstNode<'a> for NeverType<'a> {
@@ -2039,26 +2156,20 @@ impl<'a> AstNode<'a> for NeverType<'a> {
2039 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2156 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2040} 2157}
2041 2158
2042impl<'a> NeverType<'a> {} 2159impl<R: TreeRoot<RaTypes>> NeverTypeNode<R> {
2043 2160 pub fn borrowed(&self) -> NeverType {
2044// NominalDef 2161 NeverTypeNode { syntax: self.syntax.borrowed() }
2045
2046#[derive(Debug, Clone)]
2047pub struct NominalDefNode(SyntaxNode);
2048
2049impl NominalDefNode {
2050 pub fn ast(&self) -> NominalDef {
2051 NominalDef::cast(self.0.borrowed()).unwrap()
2052 } 2162 }
2053} 2163 pub fn owned(&self) -> NeverTypeNode {
2054 2164 NeverTypeNode { syntax: self.syntax.owned() }
2055impl<'a> From<NominalDef<'a>> for NominalDefNode {
2056 fn from(ast: NominalDef<'a>) -> NominalDefNode {
2057 let syntax = ast.syntax().owned();
2058 NominalDefNode(syntax)
2059 } 2165 }
2060} 2166}
2061#[derive(Debug, Clone, Copy)] 2167
2168
2169impl<'a> NeverType<'a> {}
2170
2171// NominalDef
2172#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2062pub enum NominalDef<'a> { 2173pub enum NominalDef<'a> {
2063 StructDef(StructDef<'a>), 2174 StructDef(StructDef<'a>),
2064 EnumDef(EnumDef<'a>), 2175 EnumDef(EnumDef<'a>),
@@ -2086,25 +2197,18 @@ impl<'a> ast::AttrsOwner<'a> for NominalDef<'a> {}
2086impl<'a> NominalDef<'a> {} 2197impl<'a> NominalDef<'a> {}
2087 2198
2088// Param 2199// Param
2089 2200#[derive(Debug, Clone, Copy,)]
2090#[derive(Debug, Clone)] 2201pub struct ParamNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2091pub struct ParamNode(SyntaxNode); 2202 pub(crate) syntax: SyntaxNode<R>,
2092
2093impl ParamNode {
2094 pub fn ast(&self) -> Param {
2095 Param::cast(self.0.borrowed()).unwrap()
2096 }
2097} 2203}
2204pub type Param<'a> = ParamNode<RefRoot<'a>>;
2098 2205
2099impl<'a> From<Param<'a>> for ParamNode { 2206impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamNode<R1>> for ParamNode<R2> {
2100 fn from(ast: Param<'a>) -> ParamNode { 2207 fn eq(&self, other: &ParamNode<R1>) -> bool { self.syntax == other.syntax }
2101 let syntax = ast.syntax().owned();
2102 ParamNode(syntax)
2103 }
2104} 2208}
2105#[derive(Debug, Clone, Copy)] 2209impl<R: TreeRoot<RaTypes>> Eq for ParamNode<R> {}
2106pub struct Param<'a> { 2210impl<R: TreeRoot<RaTypes>> Hash for ParamNode<R> {
2107 syntax: SyntaxNodeRef<'a>, 2211 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2108} 2212}
2109 2213
2110impl<'a> AstNode<'a> for Param<'a> { 2214impl<'a> AstNode<'a> for Param<'a> {
@@ -2117,6 +2221,16 @@ impl<'a> AstNode<'a> for Param<'a> {
2117 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2221 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2118} 2222}
2119 2223
2224impl<R: TreeRoot<RaTypes>> ParamNode<R> {
2225 pub fn borrowed(&self) -> Param {
2226 ParamNode { syntax: self.syntax.borrowed() }
2227 }
2228 pub fn owned(&self) -> ParamNode {
2229 ParamNode { syntax: self.syntax.owned() }
2230 }
2231}
2232
2233
2120impl<'a> Param<'a> { 2234impl<'a> Param<'a> {
2121 pub fn pat(self) -> Option<Pat<'a>> { 2235 pub fn pat(self) -> Option<Pat<'a>> {
2122 super::child_opt(self) 2236 super::child_opt(self)
@@ -2124,25 +2238,18 @@ impl<'a> Param<'a> {
2124} 2238}
2125 2239
2126// ParamList 2240// ParamList
2127 2241#[derive(Debug, Clone, Copy,)]
2128#[derive(Debug, Clone)] 2242pub struct ParamListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2129pub struct ParamListNode(SyntaxNode); 2243 pub(crate) syntax: SyntaxNode<R>,
2130
2131impl ParamListNode {
2132 pub fn ast(&self) -> ParamList {
2133 ParamList::cast(self.0.borrowed()).unwrap()
2134 }
2135} 2244}
2245pub type ParamList<'a> = ParamListNode<RefRoot<'a>>;
2136 2246
2137impl<'a> From<ParamList<'a>> for ParamListNode { 2247impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamListNode<R1>> for ParamListNode<R2> {
2138 fn from(ast: ParamList<'a>) -> ParamListNode { 2248 fn eq(&self, other: &ParamListNode<R1>) -> bool { self.syntax == other.syntax }
2139 let syntax = ast.syntax().owned();
2140 ParamListNode(syntax)
2141 }
2142} 2249}
2143#[derive(Debug, Clone, Copy)] 2250impl<R: TreeRoot<RaTypes>> Eq for ParamListNode<R> {}
2144pub struct ParamList<'a> { 2251impl<R: TreeRoot<RaTypes>> Hash for ParamListNode<R> {
2145 syntax: SyntaxNodeRef<'a>, 2252 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2146} 2253}
2147 2254
2148impl<'a> AstNode<'a> for ParamList<'a> { 2255impl<'a> AstNode<'a> for ParamList<'a> {
@@ -2155,6 +2262,16 @@ impl<'a> AstNode<'a> for ParamList<'a> {
2155 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2262 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2156} 2263}
2157 2264
2265impl<R: TreeRoot<RaTypes>> ParamListNode<R> {
2266 pub fn borrowed(&self) -> ParamList {
2267 ParamListNode { syntax: self.syntax.borrowed() }
2268 }
2269 pub fn owned(&self) -> ParamListNode {
2270 ParamListNode { syntax: self.syntax.owned() }
2271 }
2272}
2273
2274
2158impl<'a> ParamList<'a> { 2275impl<'a> ParamList<'a> {
2159 pub fn params(self) -> impl Iterator<Item = Param<'a>> + 'a { 2276 pub fn params(self) -> impl Iterator<Item = Param<'a>> + 'a {
2160 super::children(self) 2277 super::children(self)
@@ -2166,25 +2283,18 @@ impl<'a> ParamList<'a> {
2166} 2283}
2167 2284
2168// ParenExpr 2285// ParenExpr
2169 2286#[derive(Debug, Clone, Copy,)]
2170#[derive(Debug, Clone)] 2287pub struct ParenExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2171pub struct ParenExprNode(SyntaxNode); 2288 pub(crate) syntax: SyntaxNode<R>,
2172
2173impl ParenExprNode {
2174 pub fn ast(&self) -> ParenExpr {
2175 ParenExpr::cast(self.0.borrowed()).unwrap()
2176 }
2177} 2289}
2290pub type ParenExpr<'a> = ParenExprNode<RefRoot<'a>>;
2178 2291
2179impl<'a> From<ParenExpr<'a>> for ParenExprNode { 2292impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParenExprNode<R1>> for ParenExprNode<R2> {
2180 fn from(ast: ParenExpr<'a>) -> ParenExprNode { 2293 fn eq(&self, other: &ParenExprNode<R1>) -> bool { self.syntax == other.syntax }
2181 let syntax = ast.syntax().owned();
2182 ParenExprNode(syntax)
2183 }
2184} 2294}
2185#[derive(Debug, Clone, Copy)] 2295impl<R: TreeRoot<RaTypes>> Eq for ParenExprNode<R> {}
2186pub struct ParenExpr<'a> { 2296impl<R: TreeRoot<RaTypes>> Hash for ParenExprNode<R> {
2187 syntax: SyntaxNodeRef<'a>, 2297 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2188} 2298}
2189 2299
2190impl<'a> AstNode<'a> for ParenExpr<'a> { 2300impl<'a> AstNode<'a> for ParenExpr<'a> {
@@ -2197,28 +2307,31 @@ impl<'a> AstNode<'a> for ParenExpr<'a> {
2197 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2307 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2198} 2308}
2199 2309
2200impl<'a> ParenExpr<'a> {} 2310impl<R: TreeRoot<RaTypes>> ParenExprNode<R> {
2311 pub fn borrowed(&self) -> ParenExpr {
2312 ParenExprNode { syntax: self.syntax.borrowed() }
2313 }
2314 pub fn owned(&self) -> ParenExprNode {
2315 ParenExprNode { syntax: self.syntax.owned() }
2316 }
2317}
2201 2318
2202// ParenType
2203 2319
2204#[derive(Debug, Clone)] 2320impl<'a> ParenExpr<'a> {}
2205pub struct ParenTypeNode(SyntaxNode);
2206 2321
2207impl ParenTypeNode { 2322// ParenType
2208 pub fn ast(&self) -> ParenType { 2323#[derive(Debug, Clone, Copy,)]
2209 ParenType::cast(self.0.borrowed()).unwrap() 2324pub struct ParenTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2210 } 2325 pub(crate) syntax: SyntaxNode<R>,
2211} 2326}
2327pub type ParenType<'a> = ParenTypeNode<RefRoot<'a>>;
2212 2328
2213impl<'a> From<ParenType<'a>> for ParenTypeNode { 2329impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParenTypeNode<R1>> for ParenTypeNode<R2> {
2214 fn from(ast: ParenType<'a>) -> ParenTypeNode { 2330 fn eq(&self, other: &ParenTypeNode<R1>) -> bool { self.syntax == other.syntax }
2215 let syntax = ast.syntax().owned();
2216 ParenTypeNode(syntax)
2217 }
2218} 2331}
2219#[derive(Debug, Clone, Copy)] 2332impl<R: TreeRoot<RaTypes>> Eq for ParenTypeNode<R> {}
2220pub struct ParenType<'a> { 2333impl<R: TreeRoot<RaTypes>> Hash for ParenTypeNode<R> {
2221 syntax: SyntaxNodeRef<'a>, 2334 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2222} 2335}
2223 2336
2224impl<'a> AstNode<'a> for ParenType<'a> { 2337impl<'a> AstNode<'a> for ParenType<'a> {
@@ -2231,26 +2344,20 @@ impl<'a> AstNode<'a> for ParenType<'a> {
2231 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2344 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2232} 2345}
2233 2346
2234impl<'a> ParenType<'a> {} 2347impl<R: TreeRoot<RaTypes>> ParenTypeNode<R> {
2235 2348 pub fn borrowed(&self) -> ParenType {
2236// Pat 2349 ParenTypeNode { syntax: self.syntax.borrowed() }
2237
2238#[derive(Debug, Clone)]
2239pub struct PatNode(SyntaxNode);
2240
2241impl PatNode {
2242 pub fn ast(&self) -> Pat {
2243 Pat::cast(self.0.borrowed()).unwrap()
2244 } 2350 }
2245} 2351 pub fn owned(&self) -> ParenTypeNode {
2246 2352 ParenTypeNode { syntax: self.syntax.owned() }
2247impl<'a> From<Pat<'a>> for PatNode {
2248 fn from(ast: Pat<'a>) -> PatNode {
2249 let syntax = ast.syntax().owned();
2250 PatNode(syntax)
2251 } 2353 }
2252} 2354}
2253#[derive(Debug, Clone, Copy)] 2355
2356
2357impl<'a> ParenType<'a> {}
2358
2359// Pat
2360#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2254pub enum Pat<'a> { 2361pub enum Pat<'a> {
2255 RefPat(RefPat<'a>), 2362 RefPat(RefPat<'a>),
2256 BindPat(BindPat<'a>), 2363 BindPat(BindPat<'a>),
@@ -2299,25 +2406,18 @@ impl<'a> AstNode<'a> for Pat<'a> {
2299impl<'a> Pat<'a> {} 2406impl<'a> Pat<'a> {}
2300 2407
2301// Path 2408// Path
2302 2409#[derive(Debug, Clone, Copy,)]
2303#[derive(Debug, Clone)] 2410pub struct PathNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2304pub struct PathNode(SyntaxNode); 2411 pub(crate) syntax: SyntaxNode<R>,
2305
2306impl PathNode {
2307 pub fn ast(&self) -> Path {
2308 Path::cast(self.0.borrowed()).unwrap()
2309 }
2310} 2412}
2413pub type Path<'a> = PathNode<RefRoot<'a>>;
2311 2414
2312impl<'a> From<Path<'a>> for PathNode { 2415impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathNode<R1>> for PathNode<R2> {
2313 fn from(ast: Path<'a>) -> PathNode { 2416 fn eq(&self, other: &PathNode<R1>) -> bool { self.syntax == other.syntax }
2314 let syntax = ast.syntax().owned();
2315 PathNode(syntax)
2316 }
2317} 2417}
2318#[derive(Debug, Clone, Copy)] 2418impl<R: TreeRoot<RaTypes>> Eq for PathNode<R> {}
2319pub struct Path<'a> { 2419impl<R: TreeRoot<RaTypes>> Hash for PathNode<R> {
2320 syntax: SyntaxNodeRef<'a>, 2420 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2321} 2421}
2322 2422
2323impl<'a> AstNode<'a> for Path<'a> { 2423impl<'a> AstNode<'a> for Path<'a> {
@@ -2330,6 +2430,16 @@ impl<'a> AstNode<'a> for Path<'a> {
2330 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2430 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2331} 2431}
2332 2432
2433impl<R: TreeRoot<RaTypes>> PathNode<R> {
2434 pub fn borrowed(&self) -> Path {
2435 PathNode { syntax: self.syntax.borrowed() }
2436 }
2437 pub fn owned(&self) -> PathNode {
2438 PathNode { syntax: self.syntax.owned() }
2439 }
2440}
2441
2442
2333impl<'a> Path<'a> { 2443impl<'a> Path<'a> {
2334 pub fn segment(self) -> Option<PathSegment<'a>> { 2444 pub fn segment(self) -> Option<PathSegment<'a>> {
2335 super::child_opt(self) 2445 super::child_opt(self)
@@ -2341,25 +2451,18 @@ impl<'a> Path<'a> {
2341} 2451}
2342 2452
2343// PathExpr 2453// PathExpr
2344 2454#[derive(Debug, Clone, Copy,)]
2345#[derive(Debug, Clone)] 2455pub struct PathExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2346pub struct PathExprNode(SyntaxNode); 2456 pub(crate) syntax: SyntaxNode<R>,
2347
2348impl PathExprNode {
2349 pub fn ast(&self) -> PathExpr {
2350 PathExpr::cast(self.0.borrowed()).unwrap()
2351 }
2352} 2457}
2458pub type PathExpr<'a> = PathExprNode<RefRoot<'a>>;
2353 2459
2354impl<'a> From<PathExpr<'a>> for PathExprNode { 2460impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathExprNode<R1>> for PathExprNode<R2> {
2355 fn from(ast: PathExpr<'a>) -> PathExprNode { 2461 fn eq(&self, other: &PathExprNode<R1>) -> bool { self.syntax == other.syntax }
2356 let syntax = ast.syntax().owned();
2357 PathExprNode(syntax)
2358 }
2359} 2462}
2360#[derive(Debug, Clone, Copy)] 2463impl<R: TreeRoot<RaTypes>> Eq for PathExprNode<R> {}
2361pub struct PathExpr<'a> { 2464impl<R: TreeRoot<RaTypes>> Hash for PathExprNode<R> {
2362 syntax: SyntaxNodeRef<'a>, 2465 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2363} 2466}
2364 2467
2365impl<'a> AstNode<'a> for PathExpr<'a> { 2468impl<'a> AstNode<'a> for PathExpr<'a> {
@@ -2372,6 +2475,16 @@ impl<'a> AstNode<'a> for PathExpr<'a> {
2372 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } 2475 fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
2373} 2476}
2374 2477
2478impl<R: TreeRoot<RaTypes>> PathExprNode<R> {
2479 pub fn borrowed(&self) -> PathExpr {
2480 PathExprNode { syntax: self.syntax.borrowed() }
2481 }
2482 pub fn owned(&self) -> PathExprNode {
2483 PathExprNode { syntax: self.syntax.owned() }
2484 }
2485}
2486
2487
2375impl<'a> PathExpr<'a> { 2488impl<'a> PathExpr<'a> {
2376 pub fn path(self) -> Option<Path<'a>> { 2489 pub fn path(self) -> Option<Path<'a>> {
2377 super::child_opt(self) 2490 super::child_opt(self)
@@ -2379,25 +2492,18 @@ impl<'a> PathExpr<'a> {
2379} 2492}
2380 2493
2381// PathPat 2494// PathPat
2382 2495#[derive(Debug, Clone, Copy,)]
2383#[derive(Debug, Clone)] 2496pub struct PathPatNode<R: TreeRoot<RaTypes> = OwnedRoot> {
2384pub struct PathPatNode(SyntaxNode); 2497 pub(crate) syntax: SyntaxNode<R>,
2385
2386impl PathPatNode {
2387 pub fn ast(&self) -> PathPat {
2388 PathPat::cast(self.0.borrowed()).unwrap()
2389 }
2390} 2498}
2499pub type PathPat<'a> = PathPatNode<RefRoot<'a>>;
2391 2500
2392impl<'a> From<PathPat<'a>> for PathPatNode { 2501impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathPatNode<R1>> for PathPatNode<R2> {
2393 fn from(ast: PathPat<'a>) -> PathPatNode { 2502 fn eq(&self, other: &PathPatNode<R1>) -> bool { self.syntax == other.syntax }
2394 let syntax = ast.syntax().owned();
2395 PathPatNode(syntax)
2396 }
2397} 2503}
2398#[derive(Debug, Clone, Copy)] 2504impl<R: TreeRoot<RaTypes>> Eq for PathPatNode<R> {}
2399pub struct PathPat<'a> { 2505impl<R: TreeRoot<RaTypes>> Hash for PathPatNode<R> {
2400 syntax: SyntaxNodeRef<'a>, 2506 fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
2401} 2507}
2402