scarf_syntax/
iter.rs

1// =======================================================================
2// iter.rs
3// =======================================================================
4//! Iterating over a CST
5
6use crate::*;
7use std::cmp::{max, min};
8use std::ops::Add;
9
10/// An iterator over nodes in a syntax tree
11///
12/// Nodes are iterated across in a depth-first fashion, in the same order
13/// they appear in source files
14///
15/// ```rust
16/// # use scarf_syntax::*;
17/// /// The number of non-blocking assignments within an `always` block
18/// fn num_nonblock_assign(block: &AlwaysConstruct) -> i32 {
19///   let always_construct_node: Node = block.into();
20///   let always_construct_iter: NodeIter = always_construct_node.into();
21///   let mut count = 0;
22///   for node in always_construct_iter {
23///     if let Node::NonblockingAssignment(_) = node {
24///       count += 1;
25///     }
26///   }
27///   count
28/// }
29/// ```
30pub struct NodeIter<'a, 'b> {
31    nodes: Vec<Node<'a, 'b>>,
32}
33
34impl<'a: 'b, 'b> NodeIter<'a, 'b> {
35    /// Get the underlying nodes in the iterator
36    ///
37    /// Note that this may not contain *all* nodes
38    /// represented by the iterator, as nodes are added
39    /// during iteration to minimize storage
40    pub(crate) fn raw(self) -> Vec<Node<'a, 'b>> {
41        self.nodes
42    }
43}
44
45impl<'a: 'b, 'b> Default for NodeIter<'a, 'b> {
46    fn default() -> Self {
47        NodeIter { nodes: Vec::new() }
48    }
49}
50
51impl<'a: 'b, 'b> From<Node<'a, 'b>> for NodeIter<'a, 'b> {
52    fn from(value: Node<'a, 'b>) -> Self {
53        NodeIter { nodes: vec![value] }
54    }
55}
56
57impl<'a: 'b, 'b> Add for NodeIter<'a, 'b> {
58    type Output = Self;
59    fn add(mut self, rhs: Self) -> Self::Output {
60        self.nodes.extend(rhs.nodes);
61        self
62    }
63}
64
65impl<'a: 'b, 'b> Iterator for NodeIter<'a, 'b> {
66    type Item = Node<'a, 'b>;
67    fn next(&mut self) -> Option<Self::Item> {
68        let next = self.nodes.pop();
69        if let Some(node) = next.clone() {
70            let mut new_nodes: Vec<Node<'a, 'b>> = node.children();
71            new_nodes.reverse();
72            self.nodes.append(&mut new_nodes);
73        };
74        next
75    }
76}
77
78/// An object that can be represented as a collection of CST nodes
79///
80/// This is implemented by all individual CST nodes (see the associated
81/// data for [`Node`] variants) to represent its subtree.
82pub trait Nodes<'a: 'b, 'b> {
83    /// The nodes of the object
84    ///
85    /// This includes the object itself, as well as any/all children nodes,
86    /// provided depth-first.
87    fn nodes(&'b self) -> NodeIter<'a, 'b>;
88
89    /// The overall [`Span`] of the nodes.
90    ///
91    /// The resulting [`Span`] is for the overall node; if the node happes
92    /// to go across files, the [`Span`] will only be for the first child node
93    fn span(&'b self) -> Span<'a>;
94
95    /// Add all children nodes satisfying the given predicate to
96    /// the provided [`Vec`]
97    ///
98    /// This is faster than iterating across the entire tree, as the tree
99    /// can be evaluated completely rather than being itermediately
100    /// stored
101    fn add_nodes(
102        &'b self,
103        dest: &mut Vec<Node<'a, 'b>>,
104        pred: fn(Node<'a, 'b>) -> bool,
105    );
106
107    /// Find all children nodes satisfying the given predicate
108    ///
109    /// This is faster than iterating across the entire tree, as the tree
110    /// can be evaluated completely rather than being itermediately
111    /// stored
112    fn find(&'b self, pred: fn(Node<'a, 'b>) -> bool) -> Vec<Node<'a, 'b>> {
113        let mut result = Vec::new();
114        self.add_nodes(&mut result, pred);
115        result
116    }
117}
118
119pub(crate) fn merge_spans<'a>(span1: Span<'a>, span2: Span<'a>) -> Span<'a> {
120    if span1.file == "" {
121        span2
122    } else if span2.file == "" {
123        span1
124    } else if span1.file == span2.file {
125        Span {
126            bytes: (min(span1.bytes.start, span2.bytes.start)
127                ..max(span1.bytes.end, span2.bytes.end)),
128            ..span1
129        }
130    } else {
131        span1
132    }
133}
134
135impl<'a: 'b, 'b, T> Nodes<'a, 'b> for Box<T>
136where
137    T: Nodes<'a, 'b>,
138{
139    fn nodes(&'b self) -> NodeIter<'a, 'b> {
140        self.as_ref().nodes()
141    }
142    fn add_nodes(
143        &'b self,
144        dest: &mut Vec<Node<'a, 'b>>,
145        pred: fn(Node<'a, 'b>) -> bool,
146    ) {
147        self.as_ref().add_nodes(dest, pred);
148    }
149    fn span(&'b self) -> Span<'a> {
150        self.as_ref().span()
151    }
152}
153
154impl<'a: 'b, 'b, T> Nodes<'a, 'b> for Option<T>
155where
156    T: Nodes<'a, 'b>,
157{
158    fn nodes(&'b self) -> NodeIter<'a, 'b> {
159        match self {
160            Some(data) => data.nodes(),
161            None => NodeIter::default(),
162        }
163    }
164    fn add_nodes(
165        &'b self,
166        dest: &mut Vec<Node<'a, 'b>>,
167        pred: fn(Node<'a, 'b>) -> bool,
168    ) {
169        match self {
170            Some(data) => data.add_nodes(dest, pred),
171            None => (),
172        }
173    }
174    fn span(&'b self) -> Span<'a> {
175        match self {
176            Some(data) => data.span(),
177            None => Span::default(),
178        }
179    }
180}
181
182impl<'a: 'b, 'b, T> Nodes<'a, 'b> for Vec<T>
183where
184    T: Nodes<'a, 'b>,
185{
186    fn nodes(&'b self) -> NodeIter<'a, 'b> {
187        let mut ret: NodeIter<'a, 'b> = NodeIter::default();
188        for member in self {
189            ret = ret + member.nodes().into();
190        }
191        ret
192    }
193    fn add_nodes(
194        &'b self,
195        dest: &mut Vec<Node<'a, 'b>>,
196        pred: fn(Node<'a, 'b>) -> bool,
197    ) {
198        for member in self {
199            member.add_nodes(dest, pred);
200        }
201    }
202    fn span(&'b self) -> Span<'a> {
203        self.iter()
204            .map(|child_node| child_node.span())
205            .reduce(merge_spans)
206            .unwrap_or(Span::default())
207    }
208}
209
210impl<'a: 'b, 'b, T0, T1> Nodes<'a, 'b> for (T0, T1)
211where
212    T0: Nodes<'a, 'b>,
213    T1: Nodes<'a, 'b>,
214{
215    fn nodes(&'b self) -> NodeIter<'a, 'b> {
216        self.0.nodes() + self.1.nodes()
217    }
218    fn add_nodes(
219        &'b self,
220        dest: &mut Vec<Node<'a, 'b>>,
221        pred: fn(Node<'a, 'b>) -> bool,
222    ) {
223        self.0.add_nodes(dest, pred);
224        self.1.add_nodes(dest, pred);
225    }
226    fn span(&'b self) -> Span<'a> {
227        merge_spans(self.0.span(), self.1.span())
228    }
229}
230
231impl<'a: 'b, 'b, T0, T1, T2> Nodes<'a, 'b> for (T0, T1, T2)
232where
233    T0: Nodes<'a, 'b>,
234    T1: Nodes<'a, 'b>,
235    T2: Nodes<'a, 'b>,
236{
237    fn nodes(&'b self) -> NodeIter<'a, 'b> {
238        self.0.nodes() + self.1.nodes() + self.2.nodes()
239    }
240    fn add_nodes(
241        &'b self,
242        dest: &mut Vec<Node<'a, 'b>>,
243        pred: fn(Node<'a, 'b>) -> bool,
244    ) {
245        self.0.add_nodes(dest, pred);
246        self.1.add_nodes(dest, pred);
247        self.2.add_nodes(dest, pred);
248    }
249    fn span(&'b self) -> Span<'a> {
250        let merge_span = merge_spans(self.0.span(), self.1.span());
251        merge_spans(merge_span, self.2.span())
252    }
253}
254
255impl<'a: 'b, 'b, T0, T1, T2, T3: 'a> Nodes<'a, 'b> for (T0, T1, T2, T3)
256where
257    T0: Nodes<'a, 'b>,
258    T1: Nodes<'a, 'b>,
259    T2: Nodes<'a, 'b>,
260    T3: Nodes<'a, 'b>,
261{
262    fn nodes(&'b self) -> NodeIter<'a, 'b> {
263        self.0.nodes() + self.1.nodes() + self.2.nodes() + self.3.nodes()
264    }
265    fn add_nodes(
266        &'b self,
267        dest: &mut Vec<Node<'a, 'b>>,
268        pred: fn(Node<'a, 'b>) -> bool,
269    ) {
270        self.0.add_nodes(dest, pred);
271        self.1.add_nodes(dest, pred);
272        self.2.add_nodes(dest, pred);
273        self.3.add_nodes(dest, pred);
274    }
275    fn span(&'b self) -> Span<'a> {
276        let merge_span = merge_spans(self.0.span(), self.1.span());
277        let merge_span = merge_spans(merge_span, self.2.span());
278        merge_spans(merge_span, self.3.span())
279    }
280}
281
282impl<'a: 'b, 'b, T0, T1, T2, T3, T4: 'a> Nodes<'a, 'b> for (T0, T1, T2, T3, T4)
283where
284    T0: Nodes<'a, 'b>,
285    T1: Nodes<'a, 'b>,
286    T2: Nodes<'a, 'b>,
287    T3: Nodes<'a, 'b>,
288    T4: Nodes<'a, 'b>,
289{
290    fn nodes(&'b self) -> NodeIter<'a, 'b> {
291        self.0.nodes()
292            + self.1.nodes()
293            + self.2.nodes()
294            + self.3.nodes()
295            + self.4.nodes()
296    }
297    fn add_nodes(
298        &'b self,
299        dest: &mut Vec<Node<'a, 'b>>,
300        pred: fn(Node<'a, 'b>) -> bool,
301    ) {
302        self.0.add_nodes(dest, pred);
303        self.1.add_nodes(dest, pred);
304        self.2.add_nodes(dest, pred);
305        self.3.add_nodes(dest, pred);
306        self.4.add_nodes(dest, pred);
307    }
308    fn span(&'b self) -> Span<'a> {
309        let merge_span = merge_spans(self.0.span(), self.1.span());
310        let merge_span = merge_spans(merge_span, self.2.span());
311        let merge_span = merge_spans(merge_span, self.3.span());
312        merge_spans(merge_span, self.4.span())
313    }
314}
315
316impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5: 'a> Nodes<'a, 'b>
317    for (T0, T1, T2, T3, T4, T5)
318where
319    T0: Nodes<'a, 'b>,
320    T1: Nodes<'a, 'b>,
321    T2: Nodes<'a, 'b>,
322    T3: Nodes<'a, 'b>,
323    T4: Nodes<'a, 'b>,
324    T5: Nodes<'a, 'b>,
325{
326    fn nodes(&'b self) -> NodeIter<'a, 'b> {
327        self.0.nodes()
328            + self.1.nodes()
329            + self.2.nodes()
330            + self.3.nodes()
331            + self.4.nodes()
332            + self.5.nodes()
333    }
334    fn add_nodes(
335        &'b self,
336        dest: &mut Vec<Node<'a, 'b>>,
337        pred: fn(Node<'a, 'b>) -> bool,
338    ) {
339        self.0.add_nodes(dest, pred);
340        self.1.add_nodes(dest, pred);
341        self.2.add_nodes(dest, pred);
342        self.3.add_nodes(dest, pred);
343        self.4.add_nodes(dest, pred);
344        self.5.add_nodes(dest, pred);
345    }
346    fn span(&'b self) -> Span<'a> {
347        let merge_span = merge_spans(self.0.span(), self.1.span());
348        let merge_span = merge_spans(merge_span, self.2.span());
349        let merge_span = merge_spans(merge_span, self.3.span());
350        let merge_span = merge_spans(merge_span, self.4.span());
351        merge_spans(merge_span, self.5.span())
352    }
353}
354
355impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6: 'a> Nodes<'a, 'b>
356    for (T0, T1, T2, T3, T4, T5, T6)
357where
358    T0: Nodes<'a, 'b>,
359    T1: Nodes<'a, 'b>,
360    T2: Nodes<'a, 'b>,
361    T3: Nodes<'a, 'b>,
362    T4: Nodes<'a, 'b>,
363    T5: Nodes<'a, 'b>,
364    T6: Nodes<'a, 'b>,
365{
366    fn nodes(&'b self) -> NodeIter<'a, 'b> {
367        self.0.nodes()
368            + self.1.nodes()
369            + self.2.nodes()
370            + self.3.nodes()
371            + self.4.nodes()
372            + self.5.nodes()
373            + self.6.nodes()
374    }
375    fn add_nodes(
376        &'b self,
377        dest: &mut Vec<Node<'a, 'b>>,
378        pred: fn(Node<'a, 'b>) -> bool,
379    ) {
380        self.0.add_nodes(dest, pred);
381        self.1.add_nodes(dest, pred);
382        self.2.add_nodes(dest, pred);
383        self.3.add_nodes(dest, pred);
384        self.4.add_nodes(dest, pred);
385        self.5.add_nodes(dest, pred);
386        self.6.add_nodes(dest, pred);
387    }
388    fn span(&'b self) -> Span<'a> {
389        let merge_span = merge_spans(self.0.span(), self.1.span());
390        let merge_span = merge_spans(merge_span, self.2.span());
391        let merge_span = merge_spans(merge_span, self.3.span());
392        let merge_span = merge_spans(merge_span, self.4.span());
393        let merge_span = merge_spans(merge_span, self.5.span());
394        merge_spans(merge_span, self.6.span())
395    }
396}
397
398impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6, T7: 'a> Nodes<'a, 'b>
399    for (T0, T1, T2, T3, T4, T5, T6, T7)
400where
401    T0: Nodes<'a, 'b>,
402    T1: Nodes<'a, 'b>,
403    T2: Nodes<'a, 'b>,
404    T3: Nodes<'a, 'b>,
405    T4: Nodes<'a, 'b>,
406    T5: Nodes<'a, 'b>,
407    T6: Nodes<'a, 'b>,
408    T7: Nodes<'a, 'b>,
409{
410    fn nodes(&'b self) -> NodeIter<'a, 'b> {
411        self.0.nodes()
412            + self.1.nodes()
413            + self.2.nodes()
414            + self.3.nodes()
415            + self.4.nodes()
416            + self.5.nodes()
417            + self.6.nodes()
418            + self.7.nodes()
419    }
420    fn add_nodes(
421        &'b self,
422        dest: &mut Vec<Node<'a, 'b>>,
423        pred: fn(Node<'a, 'b>) -> bool,
424    ) {
425        self.0.add_nodes(dest, pred);
426        self.1.add_nodes(dest, pred);
427        self.2.add_nodes(dest, pred);
428        self.3.add_nodes(dest, pred);
429        self.4.add_nodes(dest, pred);
430        self.5.add_nodes(dest, pred);
431        self.6.add_nodes(dest, pred);
432        self.7.add_nodes(dest, pred);
433    }
434    fn span(&'b self) -> Span<'a> {
435        let merge_span = merge_spans(self.0.span(), self.1.span());
436        let merge_span = merge_spans(merge_span, self.2.span());
437        let merge_span = merge_spans(merge_span, self.3.span());
438        let merge_span = merge_spans(merge_span, self.4.span());
439        let merge_span = merge_spans(merge_span, self.5.span());
440        let merge_span = merge_spans(merge_span, self.6.span());
441        merge_spans(merge_span, self.7.span())
442    }
443}
444
445impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6, T7, T8> Nodes<'a, 'b>
446    for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
447where
448    T0: Nodes<'a, 'b>,
449    T1: Nodes<'a, 'b>,
450    T2: Nodes<'a, 'b>,
451    T3: Nodes<'a, 'b>,
452    T4: Nodes<'a, 'b>,
453    T5: Nodes<'a, 'b>,
454    T6: Nodes<'a, 'b>,
455    T7: Nodes<'a, 'b>,
456    T8: Nodes<'a, 'b>,
457{
458    fn nodes(&'b self) -> NodeIter<'a, 'b> {
459        self.0.nodes()
460            + self.1.nodes()
461            + self.2.nodes()
462            + self.3.nodes()
463            + self.4.nodes()
464            + self.5.nodes()
465            + self.6.nodes()
466            + self.7.nodes()
467            + self.8.nodes()
468    }
469    fn add_nodes(
470        &'b self,
471        dest: &mut Vec<Node<'a, 'b>>,
472        pred: fn(Node<'a, 'b>) -> bool,
473    ) {
474        self.0.add_nodes(dest, pred);
475        self.1.add_nodes(dest, pred);
476        self.2.add_nodes(dest, pred);
477        self.3.add_nodes(dest, pred);
478        self.4.add_nodes(dest, pred);
479        self.5.add_nodes(dest, pred);
480        self.6.add_nodes(dest, pred);
481        self.7.add_nodes(dest, pred);
482        self.8.add_nodes(dest, pred);
483    }
484    fn span(&'b self) -> Span<'a> {
485        let merge_span = merge_spans(self.0.span(), self.1.span());
486        let merge_span = merge_spans(merge_span, self.2.span());
487        let merge_span = merge_spans(merge_span, self.3.span());
488        let merge_span = merge_spans(merge_span, self.4.span());
489        let merge_span = merge_spans(merge_span, self.5.span());
490        let merge_span = merge_spans(merge_span, self.6.span());
491        let merge_span = merge_spans(merge_span, self.7.span());
492        merge_spans(merge_span, self.8.span())
493    }
494}
495
496impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Nodes<'a, 'b>
497    for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
498where
499    T0: Nodes<'a, 'b>,
500    T1: Nodes<'a, 'b>,
501    T2: Nodes<'a, 'b>,
502    T3: Nodes<'a, 'b>,
503    T4: Nodes<'a, 'b>,
504    T5: Nodes<'a, 'b>,
505    T6: Nodes<'a, 'b>,
506    T7: Nodes<'a, 'b>,
507    T8: Nodes<'a, 'b>,
508    T9: Nodes<'a, 'b>,
509{
510    fn nodes(&'b self) -> NodeIter<'a, 'b> {
511        self.0.nodes()
512            + self.1.nodes()
513            + self.2.nodes()
514            + self.3.nodes()
515            + self.4.nodes()
516            + self.5.nodes()
517            + self.6.nodes()
518            + self.7.nodes()
519            + self.8.nodes()
520            + self.9.nodes()
521    }
522    fn add_nodes(
523        &'b self,
524        dest: &mut Vec<Node<'a, 'b>>,
525        pred: fn(Node<'a, 'b>) -> bool,
526    ) {
527        self.0.add_nodes(dest, pred);
528        self.1.add_nodes(dest, pred);
529        self.2.add_nodes(dest, pred);
530        self.3.add_nodes(dest, pred);
531        self.4.add_nodes(dest, pred);
532        self.5.add_nodes(dest, pred);
533        self.6.add_nodes(dest, pred);
534        self.7.add_nodes(dest, pred);
535        self.8.add_nodes(dest, pred);
536        self.9.add_nodes(dest, pred);
537    }
538    fn span(&'b self) -> Span<'a> {
539        let merge_span = merge_spans(self.0.span(), self.1.span());
540        let merge_span = merge_spans(merge_span, self.2.span());
541        let merge_span = merge_spans(merge_span, self.3.span());
542        let merge_span = merge_spans(merge_span, self.4.span());
543        let merge_span = merge_spans(merge_span, self.5.span());
544        let merge_span = merge_spans(merge_span, self.6.span());
545        let merge_span = merge_spans(merge_span, self.7.span());
546        let merge_span = merge_spans(merge_span, self.8.span());
547        merge_spans(merge_span, self.9.span())
548    }
549}
550
551impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Nodes<'a, 'b>
552    for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
553where
554    T0: Nodes<'a, 'b>,
555    T1: Nodes<'a, 'b>,
556    T2: Nodes<'a, 'b>,
557    T3: Nodes<'a, 'b>,
558    T4: Nodes<'a, 'b>,
559    T5: Nodes<'a, 'b>,
560    T6: Nodes<'a, 'b>,
561    T7: Nodes<'a, 'b>,
562    T8: Nodes<'a, 'b>,
563    T9: Nodes<'a, 'b>,
564    T10: Nodes<'a, 'b>,
565{
566    fn nodes(&'b self) -> NodeIter<'a, 'b> {
567        self.0.nodes()
568            + self.1.nodes()
569            + self.2.nodes()
570            + self.3.nodes()
571            + self.4.nodes()
572            + self.5.nodes()
573            + self.6.nodes()
574            + self.7.nodes()
575            + self.8.nodes()
576            + self.9.nodes()
577            + self.10.nodes()
578    }
579    fn add_nodes(
580        &'b self,
581        dest: &mut Vec<Node<'a, 'b>>,
582        pred: fn(Node<'a, 'b>) -> bool,
583    ) {
584        self.0.add_nodes(dest, pred);
585        self.1.add_nodes(dest, pred);
586        self.2.add_nodes(dest, pred);
587        self.3.add_nodes(dest, pred);
588        self.4.add_nodes(dest, pred);
589        self.5.add_nodes(dest, pred);
590        self.6.add_nodes(dest, pred);
591        self.7.add_nodes(dest, pred);
592        self.8.add_nodes(dest, pred);
593        self.9.add_nodes(dest, pred);
594        self.10.add_nodes(dest, pred);
595    }
596    fn span(&'b self) -> Span<'a> {
597        let merge_span = merge_spans(self.0.span(), self.1.span());
598        let merge_span = merge_spans(merge_span, self.2.span());
599        let merge_span = merge_spans(merge_span, self.3.span());
600        let merge_span = merge_spans(merge_span, self.4.span());
601        let merge_span = merge_spans(merge_span, self.5.span());
602        let merge_span = merge_spans(merge_span, self.6.span());
603        let merge_span = merge_spans(merge_span, self.7.span());
604        let merge_span = merge_spans(merge_span, self.8.span());
605        let merge_span = merge_spans(merge_span, self.9.span());
606        merge_spans(merge_span, self.10.span())
607    }
608}
609
610impl<'a: 'b, 'b, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Nodes<'a, 'b>
611    for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
612where
613    T0: Nodes<'a, 'b>,
614    T1: Nodes<'a, 'b>,
615    T2: Nodes<'a, 'b>,
616    T3: Nodes<'a, 'b>,
617    T4: Nodes<'a, 'b>,
618    T5: Nodes<'a, 'b>,
619    T6: Nodes<'a, 'b>,
620    T7: Nodes<'a, 'b>,
621    T8: Nodes<'a, 'b>,
622    T9: Nodes<'a, 'b>,
623    T10: Nodes<'a, 'b>,
624    T11: Nodes<'a, 'b>,
625{
626    fn nodes(&'b self) -> NodeIter<'a, 'b> {
627        self.0.nodes()
628            + self.1.nodes()
629            + self.2.nodes()
630            + self.3.nodes()
631            + self.4.nodes()
632            + self.5.nodes()
633            + self.6.nodes()
634            + self.7.nodes()
635            + self.8.nodes()
636            + self.9.nodes()
637            + self.10.nodes()
638            + self.11.nodes()
639    }
640    fn add_nodes(
641        &'b self,
642        dest: &mut Vec<Node<'a, 'b>>,
643        pred: fn(Node<'a, 'b>) -> bool,
644    ) {
645        self.0.add_nodes(dest, pred);
646        self.1.add_nodes(dest, pred);
647        self.2.add_nodes(dest, pred);
648        self.3.add_nodes(dest, pred);
649        self.4.add_nodes(dest, pred);
650        self.5.add_nodes(dest, pred);
651        self.6.add_nodes(dest, pred);
652        self.7.add_nodes(dest, pred);
653        self.8.add_nodes(dest, pred);
654        self.9.add_nodes(dest, pred);
655        self.10.add_nodes(dest, pred);
656        self.11.add_nodes(dest, pred);
657    }
658    fn span(&'b self) -> Span<'a> {
659        let merge_span = merge_spans(self.0.span(), self.1.span());
660        let merge_span = merge_spans(merge_span, self.2.span());
661        let merge_span = merge_spans(merge_span, self.3.span());
662        let merge_span = merge_spans(merge_span, self.4.span());
663        let merge_span = merge_spans(merge_span, self.5.span());
664        let merge_span = merge_spans(merge_span, self.6.span());
665        let merge_span = merge_spans(merge_span, self.7.span());
666        let merge_span = merge_spans(merge_span, self.8.span());
667        let merge_span = merge_spans(merge_span, self.9.span());
668        let merge_span = merge_spans(merge_span, self.10.span());
669        merge_spans(merge_span, self.11.span())
670    }
671}
672
673impl<'a: 'b, 'b> Nodes<'a, 'b> for Metadata<'a> {
674    fn nodes(&self) -> NodeIter<'a, 'b> {
675        NodeIter::default()
676    }
677    fn add_nodes(
678        &'b self,
679        _: &mut Vec<Node<'a, 'b>>,
680        _: fn(Node<'a, 'b>) -> bool,
681    ) {
682    }
683    fn span(&'b self) -> Span<'a> {
684        self.span.clone()
685    }
686}
687
688impl<'a: 'b, 'b> Nodes<'a, 'b> for NonTriviaToken<'a> {
689    fn nodes(&self) -> NodeIter<'a, 'b> {
690        NodeIter::default()
691    }
692    fn add_nodes(
693        &'b self,
694        _: &mut Vec<Node<'a, 'b>>,
695        _: fn(Node<'a, 'b>) -> bool,
696    ) {
697    }
698    fn span(&'b self) -> Span<'a> {
699        Span::default()
700    }
701}
702
703impl<'a: 'b, 'b> Nodes<'a, 'b> for &'a str {
704    fn nodes(&self) -> NodeIter<'a, 'b> {
705        NodeIter::default()
706    }
707    fn add_nodes(
708        &'b self,
709        _: &mut Vec<Node<'a, 'b>>,
710        _: fn(Node<'a, 'b>) -> bool,
711    ) {
712    }
713    fn span(&'b self) -> Span<'a> {
714        Span::default()
715    }
716}
717
718#[cfg(test)]
719fn example_source() -> SourceText<'static> {
720    SourceText(
721        vec![],
722        None,
723        vec![Description::ModuleDeclaration(Box::new(
724            ModuleDeclaration::Ansi(Box::new(ModuleDeclarationAnsi(
725                ModuleAnsiHeader(
726                    vec![],
727                    ModuleKeyword::Module(Metadata::default()),
728                    None,
729                    ModuleIdentifier(Identifier::SimpleIdentifier((
730                        "test_module",
731                        Metadata::default(),
732                    ))),
733                    vec![],
734                    None,
735                    None,
736                    Metadata::default(),
737                ),
738                None,
739                vec![
740                    NonPortModuleItem::ModuleOrGenerate(Box::new(
741                        ModuleOrGenerateItem::ModuleCommon(
742                            Box::new((
743                                vec![],
744                                ModuleCommonItem::ModuleOrGenerateDeclaration(Box::new(
745                                    ModuleOrGenerateItemDeclaration::PackageOrGenerate(Box::new(
746                                        PackageOrGenerateItemDeclaration::Data(
747                                            Box::new(
748                                                DataDeclaration::Variable(
749                                                    Box::new((
750                                                        None,
751                                                        None,
752                                                        None,
753                                                        DataTypeOrImplicit::DataType(DataType::Vector(Box::new((
754                                                            IntegerVectorType::Logic(Metadata::default()),
755                                                            None,
756                                                            vec![]
757                                                        )))),
758                                                        ListOfVariableDeclAssignments(
759                                                            VariableDeclAssignment::Variable(Box::new((
760                                                                VariableIdentifier(Identifier::SimpleIdentifier(("my_signal", Metadata::default()))),
761                                                                vec![],
762                                                                None)
763                                                            )),
764                                                            vec![]
765                                                        ),
766                                                        Metadata::default()
767                                                    ))
768                                                )
769                                            )
770                                        )
771                                    ))
772                                ))
773                            ))
774                        )
775                    ))
776                ],
777                Metadata::default(),
778                None,
779            ))),
780        ))],
781    )
782}
783
784#[test]
785fn iterate() {
786    let source = example_source();
787    let mut nodes = source.nodes();
788    assert!(matches!(nodes.next().unwrap(), Node::SourceText(_)));
789    assert!(matches!(nodes.next().unwrap(), Node::Description(_)));
790    assert!(matches!(nodes.next().unwrap(), Node::ModuleDeclaration(_)));
791    assert!(matches!(
792        nodes.next().unwrap(),
793        Node::ModuleDeclarationAnsi(_)
794    ));
795    assert!(matches!(nodes.next().unwrap(), Node::ModuleAnsiHeader(_)));
796    assert!(matches!(nodes.next().unwrap(), Node::ModuleKeyword(_)));
797    assert!(matches!(nodes.next().unwrap(), Node::ModuleIdentifier(_)));
798    assert!(matches!(nodes.next().unwrap(), Node::Identifier(_)));
799    assert!(matches!(nodes.next().unwrap(), Node::NonPortModuleItem(_)));
800    assert!(matches!(
801        nodes.next().unwrap(),
802        Node::ModuleOrGenerateItem(_)
803    ));
804    assert!(matches!(nodes.next().unwrap(), Node::ModuleCommonItem(_)));
805    assert!(matches!(
806        nodes.next().unwrap(),
807        Node::ModuleOrGenerateItemDeclaration(_)
808    ));
809    assert!(matches!(
810        nodes.next().unwrap(),
811        Node::PackageOrGenerateItemDeclaration(_)
812    ));
813    assert!(matches!(nodes.next().unwrap(), Node::DataDeclaration(_)));
814    assert!(matches!(nodes.next().unwrap(), Node::DataTypeOrImplicit(_)));
815    assert!(matches!(nodes.next().unwrap(), Node::DataType(_)));
816    assert!(matches!(nodes.next().unwrap(), Node::IntegerVectorType(_)));
817    assert!(matches!(
818        nodes.next().unwrap(),
819        Node::ListOfVariableDeclAssignments(_)
820    ));
821    assert!(matches!(
822        nodes.next().unwrap(),
823        Node::VariableDeclAssignment(_)
824    ));
825    assert!(matches!(nodes.next().unwrap(), Node::VariableIdentifier(_)));
826    assert!(matches!(nodes.next().unwrap(), Node::Identifier(_)));
827    assert!(nodes.next().is_none());
828}
829
830#[cfg(test)]
831fn is_identifier<'a, 'b>(node: Node<'a, 'b>) -> bool {
832    matches!(node, Node::Identifier(_))
833}
834
835#[test]
836fn find() {
837    let source = example_source();
838    let source_node: Node<'_, '_> = (&source).into();
839    let identifiers: Vec<Node<'_, '_>> = source_node.find(is_identifier);
840    assert_eq!(identifiers.len(), 2);
841    let mut identifier_iter = identifiers.iter();
842    assert!(matches!(
843        identifier_iter.next().unwrap(),
844        Node::Identifier(Identifier::SimpleIdentifier(("test_module", _)))
845    ));
846    assert!(matches!(
847        identifier_iter.next().unwrap(),
848        Node::Identifier(Identifier::SimpleIdentifier(("my_signal", _)))
849    ));
850}
scarf_syntax/iter.rs

scarf_syntax/
iter.rs
