scarf_syntax/
iter.rs

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

scarf_syntax/
iter.rs
