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 194)
187    fn format_output<T>(&self, ast: &AstNode<T>, depth: usize) {
188        let spacing: String = std::iter::repeat(' ').take(depth).collect();
189
190        println!(
191            "{} {} -- '{}'::{},{}",
192            spacing,
193            std::any::type_name::<T>().split("::").last().unwrap(),
194            &self.source.to_string()[ast.start().col()..ast.end().col()],
195            ast.start().col(),
196            ast.end().col()
197        );
198    }
Source

pub fn end(&self) -> SourceLocation

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

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>,