rscel

Struct AstNode

Source 
pub struct AstNode<T> { /* private fields */ }

Implementations§

Source§

impl<T> AstNode<T>

Source

pub fn new(node: T, loc: SourceRange) -> AstNode<T>

Source

pub fn into_parts(self) -> (T, SourceRange)

Source

pub fn start(&self) -> SourceLocation

Examples found in repository?
examples/dumps_ast.rs (line 195)
188    fn format_output<T>(&self, ast: &AstNode<T>, depth: usize) {
189        let spacing: String = std::iter::repeat(' ').take(depth).collect();
190
191        println!(
192            "{} {} -- '{}'::{},{}",
193            spacing,
194            std::any::type_name::<T>().split("::").last().unwrap(),
195            &self.source.to_string()[ast.start().col()..ast.end().col()],
196            ast.start().col(),
197            ast.end().col()
198        );
199    }
Source

pub fn end(&self) -> SourceLocation

Examples found in repository?
examples/dumps_ast.rs (line 195)
188    fn format_output<T>(&self, ast: &AstNode<T>, depth: usize) {
189        let spacing: String = std::iter::repeat(' ').take(depth).collect();
190
191        println!(
192            "{} {} -- '{}'::{},{}",
193            spacing,
194            std::any::type_name::<T>().split("::").last().unwrap(),
195            &self.source.to_string()[ast.start().col()..ast.end().col()],
196            ast.start().col(),
197            ast.end().col()
198        );
199    }
Source

pub fn range(&self) -> SourceRange

Examples found in repository?
examples/explain.rs (line 111)
103    fn dump_expr_node(&self, node: &AstNode<Expr>) -> Box<RangeNode> {
104        match node.node() {
105            Expr::Unary(nxt) => self.dump_or_node(nxt),
106            Expr::Ternary {
107                condition,
108                true_clause,
109                false_clause,
110            } => Box::new(RangeNode::with_children(
111                node.range(),
112                [
113                    self.dump_or_node(condition),
114                    self.dump_or_node(true_clause),
115                    self.dump_expr_node(false_clause),
116                ]
117                .into_iter(),
118            )),
119            Expr::Match { .. } => todo!(),
120        }
121    }
122
123    fn dump_or_node(&self, node: &AstNode<ConditionalOr>) -> Box<RangeNode> {
124        match node.node() {
125            ConditionalOr::Unary(nxt) => self.dump_and_node(nxt),
126            ConditionalOr::Binary { lhs, rhs } => Box::new(RangeNode::with_children(
127                node.range(),
128                [self.dump_or_node(lhs), self.dump_and_node(rhs)].into_iter(),
129            )),
130        }
131    }
132
133    fn dump_and_node(&self, node: &AstNode<ConditionalAnd>) -> Box<RangeNode> {
134        match node.node() {
135            ConditionalAnd::Unary(nxt) => self.dump_relation(nxt),
136            ConditionalAnd::Binary { lhs, rhs } => Box::new(RangeNode::with_children(
137                node.range(),
138                [self.dump_and_node(lhs), self.dump_relation(rhs)].into_iter(),
139            )),
140        }
141    }
142
143    fn dump_relation(&self, node: &AstNode<Relation>) -> Box<RangeNode> {
144        match node.node() {
145            Relation::Unary(nxt) => self.dump_addition(nxt),
146            Relation::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
147                node.range(),
148                [self.dump_relation(lhs), self.dump_addition(rhs)].into_iter(),
149            )),
150        }
151    }
152
153    fn dump_addition(&self, node: &AstNode<Addition>) -> Box<RangeNode> {
154        match node.node() {
155            Addition::Unary(nxt) => self.dump_multiplication(nxt),
156            Addition::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
157                node.range(),
158                [self.dump_addition(lhs), self.dump_multiplication(rhs)].into_iter(),
159            )),
160        }
161    }
162
163    fn dump_multiplication(&self, node: &AstNode<Multiplication>) -> Box<RangeNode> {
164        match node.node() {
165            Multiplication::Unary(nxt) => self.dump_uniary(nxt),
166            Multiplication::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
167                node.range(),
168                [self.dump_multiplication(lhs), self.dump_uniary(rhs)].into_iter(),
169            )),
170        }
171    }
172
173    fn dump_uniary(&self, node: &AstNode<Unary>) -> Box<RangeNode> {
174        match node.node() {
175            Unary::Member(nxt) => self.dump_member(nxt),
176            Unary::NegMember { negs, member } => {
177                self.dump_neg(negs);
178                let mem = self.dump_member(member);
179                Box::new(RangeNode::with_children(node.range(), [mem].into_iter()))
180            }
181            Unary::NotMember { nots, member } => {
182                self.dump_not(nots);
183                let mem = self.dump_member(member);
184                Box::new(RangeNode::with_children(node.range(), [mem].into_iter()))
185            }
186        }
187    }
188
189    fn dump_neg(&self, node: &AstNode<NegList>) {
190        match node.node() {
191            NegList::List { tail } => self.dump_neg(tail),
192            NegList::EmptyList => {}
193        }
194    }
195
196    fn dump_not(&self, node: &AstNode<NotList>) {
197        match node.node() {
198            NotList::List { tail } => self.dump_not(tail),
199            NotList::EmptyList => {}
200        }
201    }
202
203    fn dump_member(&self, node: &AstNode<Member>) -> Box<RangeNode> {
204        let mut children = vec![self.dump_primary(&node.node().primary)];
205        for member in node.node().member.iter() {
206            children.push(self.dump_member_prime(member));
207        }
208
209        Box::new(RangeNode::with_children(node.range(), children.into_iter()))
210    }
211
212    fn dump_primary(&self, node: &AstNode<Primary>) -> Box<RangeNode> {
213        match node.node() {
214            Primary::Type => Box::new(RangeNode::empty(node.range())),
215            Primary::Ident(_) => Box::new(RangeNode::empty(node.range())),
216            Primary::Parens(expr) => Box::new(RangeNode::with_children(
217                node.range(),
218                [self.dump_expr_node(expr)].into_iter(),
219            )),
220            Primary::ListConstruction(exprs) => self.dump_expr_list(exprs),
221            Primary::ObjectInit(objinits) => self.dump_obj_inits(objinits),
222            Primary::Literal(_) => Box::new(RangeNode::empty(node.range())),
223        }
224    }
225
226    fn dump_member_prime(&self, node: &AstNode<MemberPrime>) -> Box<RangeNode> {
227        match node.node() {
228            MemberPrime::MemberAccess { ident } => self.dump_ident(&ident),
229            MemberPrime::Call { call } => self.dump_expr_list(call),
230            MemberPrime::ArrayAccess { access } => self.dump_expr_node(access),
231            MemberPrime::Empty => Box::new(RangeNode::empty(node.range())),
232        }
233    }
234
235    fn dump_ident(&self, node: &AstNode<Ident>) -> Box<RangeNode> {
236        Box::new(RangeNode::empty(node.range()))
237    }
238
239    fn dump_expr_list(&self, node: &AstNode<ExprList>) -> Box<RangeNode> {
240        Box::new(RangeNode::with_children(
241            node.range(),
242            node.node()
243                .exprs
244                .clone()
245                .into_iter()
246                .map(|x| self.dump_expr_node(&x)),
247        ))
248    }
249
250    fn dump_obj_inits(&self, node: &AstNode<ObjInits>) -> Box<RangeNode> {
251        Box::new(RangeNode::with_children(
252            node.range(),
253            node.node()
254                .inits
255                .clone()
256                .into_iter()
257                .map(|x| self.dump_obj_init(&x)),
258        ))
259    }
260
261    fn dump_obj_init(&self, node: &AstNode<ObjInit>) -> Box<RangeNode> {
262        self.dump_expr_node(&node.node().key);
263        self.dump_expr_node(&node.node().value);
264        Box::new(RangeNode::empty(node.range()))
265    }
Source

pub fn node(&self) -> &T

Examples found in repository?
examples/dumps_ast.rs (line 31)
29    fn dump_expr_node(&self, node: &AstNode<Expr>, depth: usize) {
30        self.format_output(node, depth);
31        match node.node() {
32            Expr::Unary(nxt) => self.dump_or_node(nxt, depth + 1),
33            Expr::Ternary {
34                condition,
35                true_clause,
36                false_clause,
37            } => {
38                self.dump_or_node(condition, depth + 1);
39                self.dump_or_node(true_clause, depth + 1);
40                self.dump_expr_node(false_clause, depth + 1);
41            }
42            Expr::Match { .. } => todo!(),
43        }
44    }
45
46    fn dump_or_node(&self, node: &AstNode<ConditionalOr>, depth: usize) {
47        self.format_output(node, depth);
48        match node.node() {
49            ConditionalOr::Unary(nxt) => self.dump_and_node(nxt, depth + 1),
50            ConditionalOr::Binary { lhs, rhs } => {
51                self.dump_or_node(lhs, depth + 1);
52                self.dump_and_node(rhs, depth + 1)
53            }
54        }
55    }
56
57    fn dump_and_node(&self, node: &AstNode<ConditionalAnd>, depth: usize) {
58        self.format_output(node, depth);
59        match node.node() {
60            ConditionalAnd::Unary(nxt) => self.dump_relation(nxt, depth + 1),
61            ConditionalAnd::Binary { lhs, rhs } => {
62                self.dump_and_node(lhs, depth + 1);
63                self.dump_relation(rhs, depth + 1);
64            }
65        }
66    }
67
68    fn dump_relation(&self, node: &AstNode<Relation>, depth: usize) {
69        self.format_output(node, depth);
70        match node.node() {
71            Relation::Unary(nxt) => self.dump_addition(nxt, depth + 1),
72            Relation::Binary { lhs, op: _op, rhs } => {
73                self.dump_relation(lhs, depth + 1);
74                self.dump_addition(rhs, depth + 1);
75            }
76        }
77    }
78
79    fn dump_addition(&self, node: &AstNode<Addition>, depth: usize) {
80        self.format_output(node, depth);
81        match node.node() {
82            Addition::Unary(nxt) => self.dump_multiplication(nxt, depth + 1),
83            Addition::Binary { lhs, op: _op, rhs } => {
84                self.dump_addition(lhs, depth + 1);
85                self.dump_multiplication(rhs, depth + 1);
86            }
87        }
88    }
89
90    fn dump_multiplication(&self, node: &AstNode<Multiplication>, depth: usize) {
91        self.format_output(node, depth);
92        match node.node() {
93            Multiplication::Unary(nxt) => self.dump_uniary(nxt, depth + 1),
94            Multiplication::Binary { lhs, op: _op, rhs } => {
95                self.dump_multiplication(lhs, depth + 1);
96                self.dump_uniary(rhs, depth + 1);
97            }
98        }
99    }
100
101    fn dump_uniary(&self, node: &AstNode<Unary>, depth: usize) {
102        self.format_output(node, depth);
103        match node.node() {
104            Unary::Member(nxt) => self.dump_member(nxt, depth + 1),
105            Unary::NegMember { negs, member } => {
106                self.dump_neg(negs, depth + 1);
107                self.dump_member(member, depth + 1);
108            }
109            Unary::NotMember { nots, member } => {
110                self.dump_not(nots, depth + 1);
111                self.dump_member(member, depth + 1);
112            }
113        }
114    }
115
116    fn dump_neg(&self, node: &AstNode<NegList>, depth: usize) {
117        self.format_output(node, depth);
118        match node.node() {
119            NegList::List { tail } => self.dump_neg(tail, depth + 1),
120            NegList::EmptyList => {}
121        }
122    }
123
124    fn dump_not(&self, node: &AstNode<NotList>, depth: usize) {
125        self.format_output(node, depth);
126        match node.node() {
127            NotList::List { tail } => self.dump_not(tail, depth + 1),
128            NotList::EmptyList => {}
129        }
130    }
131
132    fn dump_member(&self, node: &AstNode<Member>, depth: usize) {
133        self.format_output(node, depth);
134        self.dump_primary(&node.node().primary, depth + 1);
135        for member in node.node().member.iter() {
136            self.dump_member_prime(member, depth + 1);
137        }
138    }
139
140    fn dump_primary(&self, node: &AstNode<Primary>, depth: usize) {
141        self.format_output(node, depth);
142        match node.node() {
143            Primary::Type => {}
144            Primary::Ident(_) => {}
145            Primary::Parens(expr) => self.dump_expr_node(expr, depth + 1),
146            Primary::ListConstruction(exprs) => self.dump_expr_list(exprs, depth + 1),
147            Primary::ObjectInit(objinits) => self.dump_obj_inits(objinits, depth + 1),
148            Primary::Literal(_) => {}
149        }
150    }
151
152    fn dump_member_prime(&self, node: &AstNode<MemberPrime>, depth: usize) {
153        self.format_output(node, depth);
154        match node.node() {
155            MemberPrime::MemberAccess { ident } => {
156                self.dump_ident(&ident, depth + 1);
157            }
158            MemberPrime::Call { call } => self.dump_expr_list(call, depth + 1),
159            MemberPrime::ArrayAccess { access } => self.dump_expr_node(access, depth + 1),
160            MemberPrime::Empty => {}
161        }
162    }
163
164    fn dump_ident(&self, node: &AstNode<Ident>, depth: usize) {
165        self.format_output(node, depth);
166    }
167
168    fn dump_expr_list(&self, node: &AstNode<ExprList>, depth: usize) {
169        self.format_output(node, depth);
170        for expr in node.node().exprs.iter() {
171            self.dump_expr_node(expr, depth + 1);
172        }
173    }
174
175    fn dump_obj_inits(&self, node: &AstNode<ObjInits>, depth: usize) {
176        self.format_output(node, depth);
177        for init in node.node().inits.iter() {
178            self.dump_obj_init(init, depth + 1);
179        }
180    }
181
182    fn dump_obj_init(&self, node: &AstNode<ObjInit>, depth: usize) {
183        self.format_output(node, depth);
184        self.dump_expr_node(&node.node().key, depth + 1);
185        self.dump_expr_node(&node.node().value, depth + 1);
186    }
More examples
Hide additional examples
examples/explain.rs (line 104)
103    fn dump_expr_node(&self, node: &AstNode<Expr>) -> Box<RangeNode> {
104        match node.node() {
105            Expr::Unary(nxt) => self.dump_or_node(nxt),
106            Expr::Ternary {
107                condition,
108                true_clause,
109                false_clause,
110            } => Box::new(RangeNode::with_children(
111                node.range(),
112                [
113                    self.dump_or_node(condition),
114                    self.dump_or_node(true_clause),
115                    self.dump_expr_node(false_clause),
116                ]
117                .into_iter(),
118            )),
119            Expr::Match { .. } => todo!(),
120        }
121    }
122
123    fn dump_or_node(&self, node: &AstNode<ConditionalOr>) -> Box<RangeNode> {
124        match node.node() {
125            ConditionalOr::Unary(nxt) => self.dump_and_node(nxt),
126            ConditionalOr::Binary { lhs, rhs } => Box::new(RangeNode::with_children(
127                node.range(),
128                [self.dump_or_node(lhs), self.dump_and_node(rhs)].into_iter(),
129            )),
130        }
131    }
132
133    fn dump_and_node(&self, node: &AstNode<ConditionalAnd>) -> Box<RangeNode> {
134        match node.node() {
135            ConditionalAnd::Unary(nxt) => self.dump_relation(nxt),
136            ConditionalAnd::Binary { lhs, rhs } => Box::new(RangeNode::with_children(
137                node.range(),
138                [self.dump_and_node(lhs), self.dump_relation(rhs)].into_iter(),
139            )),
140        }
141    }
142
143    fn dump_relation(&self, node: &AstNode<Relation>) -> Box<RangeNode> {
144        match node.node() {
145            Relation::Unary(nxt) => self.dump_addition(nxt),
146            Relation::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
147                node.range(),
148                [self.dump_relation(lhs), self.dump_addition(rhs)].into_iter(),
149            )),
150        }
151    }
152
153    fn dump_addition(&self, node: &AstNode<Addition>) -> Box<RangeNode> {
154        match node.node() {
155            Addition::Unary(nxt) => self.dump_multiplication(nxt),
156            Addition::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
157                node.range(),
158                [self.dump_addition(lhs), self.dump_multiplication(rhs)].into_iter(),
159            )),
160        }
161    }
162
163    fn dump_multiplication(&self, node: &AstNode<Multiplication>) -> Box<RangeNode> {
164        match node.node() {
165            Multiplication::Unary(nxt) => self.dump_uniary(nxt),
166            Multiplication::Binary { lhs, op: _op, rhs } => Box::new(RangeNode::with_children(
167                node.range(),
168                [self.dump_multiplication(lhs), self.dump_uniary(rhs)].into_iter(),
169            )),
170        }
171    }
172
173    fn dump_uniary(&self, node: &AstNode<Unary>) -> Box<RangeNode> {
174        match node.node() {
175            Unary::Member(nxt) => self.dump_member(nxt),
176            Unary::NegMember { negs, member } => {
177                self.dump_neg(negs);
178                let mem = self.dump_member(member);
179                Box::new(RangeNode::with_children(node.range(), [mem].into_iter()))
180            }
181            Unary::NotMember { nots, member } => {
182                self.dump_not(nots);
183                let mem = self.dump_member(member);
184                Box::new(RangeNode::with_children(node.range(), [mem].into_iter()))
185            }
186        }
187    }
188
189    fn dump_neg(&self, node: &AstNode<NegList>) {
190        match node.node() {
191            NegList::List { tail } => self.dump_neg(tail),
192            NegList::EmptyList => {}
193        }
194    }
195
196    fn dump_not(&self, node: &AstNode<NotList>) {
197        match node.node() {
198            NotList::List { tail } => self.dump_not(tail),
199            NotList::EmptyList => {}
200        }
201    }
202
203    fn dump_member(&self, node: &AstNode<Member>) -> Box<RangeNode> {
204        let mut children = vec![self.dump_primary(&node.node().primary)];
205        for member in node.node().member.iter() {
206            children.push(self.dump_member_prime(member));
207        }
208
209        Box::new(RangeNode::with_children(node.range(), children.into_iter()))
210    }
211
212    fn dump_primary(&self, node: &AstNode<Primary>) -> Box<RangeNode> {
213        match node.node() {
214            Primary::Type => Box::new(RangeNode::empty(node.range())),
215            Primary::Ident(_) => Box::new(RangeNode::empty(node.range())),
216            Primary::Parens(expr) => Box::new(RangeNode::with_children(
217                node.range(),
218                [self.dump_expr_node(expr)].into_iter(),
219            )),
220            Primary::ListConstruction(exprs) => self.dump_expr_list(exprs),
221            Primary::ObjectInit(objinits) => self.dump_obj_inits(objinits),
222            Primary::Literal(_) => Box::new(RangeNode::empty(node.range())),
223        }
224    }
225
226    fn dump_member_prime(&self, node: &AstNode<MemberPrime>) -> Box<RangeNode> {
227        match node.node() {
228            MemberPrime::MemberAccess { ident } => self.dump_ident(&ident),
229            MemberPrime::Call { call } => self.dump_expr_list(call),
230            MemberPrime::ArrayAccess { access } => self.dump_expr_node(access),
231            MemberPrime::Empty => Box::new(RangeNode::empty(node.range())),
232        }
233    }
234
235    fn dump_ident(&self, node: &AstNode<Ident>) -> Box<RangeNode> {
236        Box::new(RangeNode::empty(node.range()))
237    }
238
239    fn dump_expr_list(&self, node: &AstNode<ExprList>) -> Box<RangeNode> {
240        Box::new(RangeNode::with_children(
241            node.range(),
242            node.node()
243                .exprs
244                .clone()
245                .into_iter()
246                .map(|x| self.dump_expr_node(&x)),
247        ))
248    }
249
250    fn dump_obj_inits(&self, node: &AstNode<ObjInits>) -> Box<RangeNode> {
251        Box::new(RangeNode::with_children(
252            node.range(),
253            node.node()
254                .inits
255                .clone()
256                .into_iter()
257                .map(|x| self.dump_obj_init(&x)),
258        ))
259    }
260
261    fn dump_obj_init(&self, node: &AstNode<ObjInit>) -> Box<RangeNode> {
262        self.dump_expr_node(&node.node().key);
263        self.dump_expr_node(&node.node().value);
264        Box::new(RangeNode::empty(node.range()))
265    }

Trait Implementations§

Source§

impl<T: Clone> Clone for AstNode<T>

Source§

fn clone(&self) -> AstNode<T>

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<T: Debug> Debug for AstNode<T>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<'de, T> Deserialize<'de> for AstNode<T>
where T: Deserialize<'de>,

Source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl<T: PartialEq> PartialEq for AstNode<T>

Source§

fn eq(&self, other: &AstNode<T>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<T> Serialize for AstNode<T>
where T: Serialize,

Source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
Source§

impl<T> StructuralPartialEq for AstNode<T>

Auto Trait Implementations§

§

impl<T> Freeze for AstNode<T>
where T: Freeze,

§

impl<T> RefUnwindSafe for AstNode<T>
where T: RefUnwindSafe,

§

impl<T> Send for AstNode<T>
where T: Send,

§

impl<T> Sync for AstNode<T>
where T: Sync,

§

impl<T> Unpin for AstNode<T>
where T: Unpin,

§

impl<T> UnwindSafe for AstNode<T>
where T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,