syn_sem/syntax/
common.rs

1pub use attr_help::AttributeHelper;
2pub use find_children::FindChildren;
3pub use find_parent::{InsertRelation, ParentFinder};
4pub use identify::{IdentifySyn, SynId};
5
6mod identify {
7    use std::{
8        any::{Any, TypeId},
9        fmt, hash,
10    };
11    use syn_locator::Locate;
12
13    pub trait IdentifySyn: Any + Locate {
14        fn as_any(&self) -> &dyn Any;
15
16        fn syn_id(&self) -> SynId
17        where
18            Self: Sized,
19        {
20            SynId {
21                trait_ptr: self as *const Self as *const dyn IdentifySyn,
22                type_id: self.type_id(),
23            }
24        }
25
26        fn content(&self) -> String {
27            Locate::code(self)
28        }
29
30        fn type_name(&self) -> &'static str;
31    }
32
33    #[derive(Clone, Copy)]
34    pub struct SynId {
35        trait_ptr: *const dyn IdentifySyn,
36
37        /// Supports unique syn node identification.
38        ///
39        /// # Why trait pointer is not sufficient
40        ///
41        /// * Metadata(vtable pointer) of the trait pointer cannot be used for identification.
42        ///   - See https://doc.rust-lang.org/std/ptr/struct.DynMetadata.html
43        /// * Data address of the trait pointer is not sufficient.
44        ///   - A transparent type would have the same data address as what its child has.
45        /// * As a result, we need more data for the unique syn node identification.
46        type_id: TypeId,
47    }
48
49    impl SynId {
50        pub fn content(&self) -> String {
51            unsafe { self.trait_ptr.as_ref().unwrap() }.content()
52        }
53
54        pub fn as_identify_syn(&self) -> &dyn IdentifySyn {
55            unsafe { self.trait_ptr.as_ref().unwrap() }
56        }
57
58        pub fn as_any(&self) -> &dyn Any {
59            let r = unsafe { self.trait_ptr.as_ref().unwrap() };
60            r.as_any()
61        }
62
63        pub fn as_ref<T: Any>(&self) -> Option<&T> {
64            self.as_any().downcast_ref::<T>()
65        }
66
67        pub fn as_const_ptr<T: Any>(&self) -> Option<*const T> {
68            self.as_ref().map(|ref_| ref_ as *const T)
69        }
70
71        pub fn type_name(&self) -> &'static str {
72            unsafe { self.trait_ptr.as_ref().unwrap() }.type_name()
73        }
74    }
75
76    impl PartialEq for SynId {
77        fn eq(&self, other: &Self) -> bool {
78            // Ignores metadata (vtable pointer)
79            self.trait_ptr as *const () == other.trait_ptr as *const ()
80                && self.type_id == other.type_id
81        }
82    }
83
84    impl Eq for SynId {}
85
86    impl hash::Hash for SynId {
87        fn hash<H: hash::Hasher>(&self, state: &mut H) {
88            // Ignores metadata (vtable pointer)
89            (self.trait_ptr as *const ()).hash(state);
90            self.type_id.hash(state);
91        }
92    }
93
94    impl fmt::Debug for SynId {
95        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
96            self.trait_ptr.fmt(f)
97        }
98    }
99
100    impl fmt::Display for SynId {
101        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102            fmt::Debug::fmt(self, f)
103        }
104    }
105}
106
107mod attr_help {
108    use proc_macro2::TokenStream as TokenStream2;
109    use std::mem;
110
111    // Allow dead code for future use
112    #[allow(dead_code)]
113    pub trait AttributeHelper {
114        fn get_attributes(&self) -> Option<&Vec<syn::Attribute>>;
115
116        fn get_mut_attributes(&mut self) -> Option<&mut Vec<syn::Attribute>>;
117
118        fn get_attribute(&self, path: &str) -> Option<&syn::Attribute> {
119            self.get_attributes()?
120                .iter()
121                .find(|attr| attr.path().is_ident(path))
122        }
123
124        fn get_mut_attribute(&mut self, path: &str) -> Option<&mut syn::Attribute> {
125            self.get_mut_attributes()?
126                .iter_mut()
127                .find(|attr| attr.path().is_ident(path))
128        }
129
130        fn contains_attribute(&self, path: &str) -> bool {
131            let Some(attrs) = self.get_attributes() else {
132                return false;
133            };
134            attrs.iter().any(|attr| attr.path().is_ident(path))
135        }
136
137        fn remove_attribute(&mut self, path: &str) {
138            let Some(attrs) = self.get_mut_attributes() else {
139                return;
140            };
141            attrs.retain(|attr| !attr.path().is_ident(path))
142        }
143
144        fn replace_attributes(&mut self, new: Vec<syn::Attribute>) -> Vec<syn::Attribute> {
145            let Some(old) = self.get_mut_attributes() else {
146                return Vec::new();
147            };
148            mem::replace(old, new)
149        }
150
151        /// Expands this vector by attaching the given value to the front of this vector.
152        fn insert_front(&mut self, mut front: Vec<syn::Attribute>) {
153            let Some(this) = self.get_mut_attributes() else {
154                return;
155            };
156            front.append(this);
157            let _ = mem::replace(this, front);
158        }
159
160        /// #\[path(inner)\]
161        fn get_attribute_inner(&self, path: &str) -> Option<&TokenStream2> {
162            let attr = self.get_attribute(path)?;
163            if let syn::Meta::List(l) = &attr.meta {
164                Some(&l.tokens)
165            } else {
166                None
167            }
168        }
169
170        /// #\[path = value\]
171        fn get_attribute_value(&self, path: &str) -> Option<&syn::Expr> {
172            let attr = self.get_attribute(path)?;
173            if let syn::Meta::NameValue(nv) = &attr.meta {
174                Some(&nv.value)
175            } else {
176                None
177            }
178        }
179    }
180
181    macro_rules! impl_attribute_helper_for_simple {
182        ($ty:ty) => {
183            impl AttributeHelper for $ty {
184                fn get_attributes(&self) -> Option<&Vec<syn::Attribute>> {
185                    Some(&self.attrs)
186                }
187
188                fn get_mut_attributes(&mut self) -> Option<&mut Vec<syn::Attribute>> {
189                    Some(&mut self.attrs)
190                }
191            }
192        };
193    }
194
195    impl_attribute_helper_for_simple!(syn::ExprArray);
196    impl_attribute_helper_for_simple!(syn::ExprAssign);
197    impl_attribute_helper_for_simple!(syn::ExprAsync);
198    impl_attribute_helper_for_simple!(syn::ExprAwait);
199    impl_attribute_helper_for_simple!(syn::ExprBinary);
200    impl_attribute_helper_for_simple!(syn::ExprBlock);
201    impl_attribute_helper_for_simple!(syn::ExprBreak);
202    impl_attribute_helper_for_simple!(syn::ExprCall);
203    impl_attribute_helper_for_simple!(syn::ExprCast);
204    impl_attribute_helper_for_simple!(syn::ExprClosure);
205    impl_attribute_helper_for_simple!(syn::ExprConst);
206    impl_attribute_helper_for_simple!(syn::ExprContinue);
207    impl_attribute_helper_for_simple!(syn::ExprField);
208    impl_attribute_helper_for_simple!(syn::ExprForLoop);
209    impl_attribute_helper_for_simple!(syn::ExprGroup);
210    impl_attribute_helper_for_simple!(syn::ExprIf);
211    impl_attribute_helper_for_simple!(syn::ExprIndex);
212    impl_attribute_helper_for_simple!(syn::ExprInfer);
213    impl_attribute_helper_for_simple!(syn::ExprLet);
214    impl_attribute_helper_for_simple!(syn::ExprLit);
215    impl_attribute_helper_for_simple!(syn::ExprLoop);
216    impl_attribute_helper_for_simple!(syn::ExprMacro);
217    impl_attribute_helper_for_simple!(syn::ExprMatch);
218    impl_attribute_helper_for_simple!(syn::ExprMethodCall);
219    impl_attribute_helper_for_simple!(syn::ExprParen);
220    impl_attribute_helper_for_simple!(syn::ExprPath);
221    impl_attribute_helper_for_simple!(syn::ExprRange);
222    impl_attribute_helper_for_simple!(syn::ExprRawAddr);
223    impl_attribute_helper_for_simple!(syn::ExprReference);
224    impl_attribute_helper_for_simple!(syn::ExprRepeat);
225    impl_attribute_helper_for_simple!(syn::ExprReturn);
226    impl_attribute_helper_for_simple!(syn::ExprStruct);
227    impl_attribute_helper_for_simple!(syn::ExprTry);
228    impl_attribute_helper_for_simple!(syn::ExprTryBlock);
229    impl_attribute_helper_for_simple!(syn::ExprTuple);
230    impl_attribute_helper_for_simple!(syn::ExprUnary);
231    impl_attribute_helper_for_simple!(syn::ExprUnsafe);
232    impl_attribute_helper_for_simple!(syn::ExprWhile);
233    impl_attribute_helper_for_simple!(syn::ExprYield);
234    impl_attribute_helper_for_simple!(syn::Field);
235    impl_attribute_helper_for_simple!(syn::ItemConst);
236    impl_attribute_helper_for_simple!(syn::ItemMod);
237    impl_attribute_helper_for_simple!(syn::ItemStruct);
238
239    impl AttributeHelper for syn::Item {
240        fn get_attributes(&self) -> Option<&Vec<syn::Attribute>> {
241            match self {
242                syn::Item::Const(v) => v.get_attributes(),
243                syn::Item::Mod(v) => v.get_attributes(),
244                syn::Item::Struct(v) => v.get_attributes(),
245                _ => None,
246            }
247        }
248
249        fn get_mut_attributes(&mut self) -> Option<&mut Vec<syn::Attribute>> {
250            match self {
251                syn::Item::Const(v) => v.get_mut_attributes(),
252                syn::Item::Mod(v) => v.get_mut_attributes(),
253                syn::Item::Struct(v) => v.get_mut_attributes(),
254                _ => None,
255            }
256        }
257    }
258
259    impl AttributeHelper for syn::Expr {
260        fn get_attributes(&self) -> Option<&Vec<syn::Attribute>> {
261            match self {
262                Self::Array(v) => v.get_attributes(),
263                Self::Assign(v) => v.get_attributes(),
264                Self::Async(v) => v.get_attributes(),
265                Self::Await(v) => v.get_attributes(),
266                Self::Binary(v) => v.get_attributes(),
267                Self::Block(v) => v.get_attributes(),
268                Self::Break(v) => v.get_attributes(),
269                Self::Call(v) => v.get_attributes(),
270                Self::Cast(v) => v.get_attributes(),
271                Self::Closure(v) => v.get_attributes(),
272                Self::Const(v) => v.get_attributes(),
273                Self::Continue(v) => v.get_attributes(),
274                Self::Field(v) => v.get_attributes(),
275                Self::ForLoop(v) => v.get_attributes(),
276                Self::Group(v) => v.get_attributes(),
277                Self::If(v) => v.get_attributes(),
278                Self::Index(v) => v.get_attributes(),
279                Self::Infer(v) => v.get_attributes(),
280                Self::Let(v) => v.get_attributes(),
281                Self::Lit(v) => v.get_attributes(),
282                Self::Loop(v) => v.get_attributes(),
283                Self::Macro(v) => v.get_attributes(),
284                Self::Match(v) => v.get_attributes(),
285                Self::MethodCall(v) => v.get_attributes(),
286                Self::Paren(v) => v.get_attributes(),
287                Self::Path(v) => v.get_attributes(),
288                Self::Range(v) => v.get_attributes(),
289                Self::RawAddr(v) => v.get_attributes(),
290                Self::Reference(v) => v.get_attributes(),
291                Self::Repeat(v) => v.get_attributes(),
292                Self::Return(v) => v.get_attributes(),
293                Self::Struct(v) => v.get_attributes(),
294                Self::Try(v) => v.get_attributes(),
295                Self::TryBlock(v) => v.get_attributes(),
296                Self::Tuple(v) => v.get_attributes(),
297                Self::Unary(v) => v.get_attributes(),
298                Self::Unsafe(v) => v.get_attributes(),
299                Self::Verbatim(_) => None,
300                Self::While(v) => v.get_attributes(),
301                Self::Yield(v) => v.get_attributes(),
302                _ => unreachable!("non-exhaustive"),
303            }
304        }
305
306        fn get_mut_attributes(&mut self) -> Option<&mut Vec<syn::Attribute>> {
307            match self {
308                Self::Array(v) => v.get_mut_attributes(),
309                Self::Assign(v) => v.get_mut_attributes(),
310                Self::Async(v) => v.get_mut_attributes(),
311                Self::Await(v) => v.get_mut_attributes(),
312                Self::Binary(v) => v.get_mut_attributes(),
313                Self::Block(v) => v.get_mut_attributes(),
314                Self::Break(v) => v.get_mut_attributes(),
315                Self::Call(v) => v.get_mut_attributes(),
316                Self::Cast(v) => v.get_mut_attributes(),
317                Self::Closure(v) => v.get_mut_attributes(),
318                Self::Const(v) => v.get_mut_attributes(),
319                Self::Continue(v) => v.get_mut_attributes(),
320                Self::Field(v) => v.get_mut_attributes(),
321                Self::ForLoop(v) => v.get_mut_attributes(),
322                Self::Group(v) => v.get_mut_attributes(),
323                Self::If(v) => v.get_mut_attributes(),
324                Self::Index(v) => v.get_mut_attributes(),
325                Self::Infer(v) => v.get_mut_attributes(),
326                Self::Let(v) => v.get_mut_attributes(),
327                Self::Lit(v) => v.get_mut_attributes(),
328                Self::Loop(v) => v.get_mut_attributes(),
329                Self::Macro(v) => v.get_mut_attributes(),
330                Self::Match(v) => v.get_mut_attributes(),
331                Self::MethodCall(v) => v.get_mut_attributes(),
332                Self::Paren(v) => v.get_mut_attributes(),
333                Self::Path(v) => v.get_mut_attributes(),
334                Self::Range(v) => v.get_mut_attributes(),
335                Self::RawAddr(v) => v.get_mut_attributes(),
336                Self::Reference(v) => v.get_mut_attributes(),
337                Self::Repeat(v) => v.get_mut_attributes(),
338                Self::Return(v) => v.get_mut_attributes(),
339                Self::Struct(v) => v.get_mut_attributes(),
340                Self::Try(v) => v.get_mut_attributes(),
341                Self::TryBlock(v) => v.get_mut_attributes(),
342                Self::Tuple(v) => v.get_mut_attributes(),
343                Self::Unary(v) => v.get_mut_attributes(),
344                Self::Unsafe(v) => v.get_mut_attributes(),
345                Self::Verbatim(_) => None,
346                Self::While(v) => v.get_mut_attributes(),
347                Self::Yield(v) => v.get_mut_attributes(),
348                _ => unreachable!("non-exhaustive"),
349            }
350        }
351    }
352}
353
354mod find_parent {
355    use super::identify::{IdentifySyn, SynId};
356    use crate::Map;
357    use std::{any::TypeId, iter, slice};
358    use syn::punctuated;
359
360    #[derive(Debug, Clone)]
361    pub struct ParentFinder {
362        /// Mapping child -> parent.
363        map: Map<SynId, SynId>,
364    }
365
366    impl ParentFinder {
367        pub(crate) fn new() -> Self {
368            Self {
369                map: Map::default(),
370            }
371        }
372
373        pub(crate) fn insert(&mut self, child: SynId, parent: SynId) {
374            let _old_parent = self.map.insert(child, parent);
375
376            #[cfg(debug_assertions)]
377            if let Some(old_parent) = _old_parent {
378                panic!(
379                    "conflict parent-child syn id: child: {}, old parent: {}, new parent: {}",
380                    child.content(),
381                    old_parent.content(),
382                    parent.content()
383                );
384            }
385        }
386
387        pub(crate) fn get_parent(&self, child: SynId) -> Option<&SynId> {
388            self.map.get(&child)
389        }
390
391        /// Finds the nearest ancestor that is one type of the given types in the syntax tree.
392        ///
393        /// If found, returns its index to the `target_ancestors` and its syn id.
394        pub(crate) fn get_ancestor(
395            &self,
396            child: SynId,
397            target_ancestors: &[TypeId],
398        ) -> Option<(usize, SynId)> {
399            let mut cur = child;
400            while let Some(parent) = self.get_parent(cur) {
401                if let Some((index, _)) = target_ancestors
402                    .iter()
403                    .enumerate()
404                    .find(|(_, target)| **target == parent.as_any().type_id())
405                {
406                    return Some((index, *parent));
407                }
408                cur = *parent;
409            }
410            None
411        }
412    }
413
414    pub trait InsertRelation {
415        /// Inserts parent-child relations to the given `finder`.
416        ///
417        /// Implementers are encouraged to call the same method on children as well so that clients
418        /// can get the whole relationship by just one function call.
419        fn insert_relation(&self, finder: &mut ParentFinder);
420    }
421
422    impl<T: InsertRelation> InsertRelation for Option<T> {
423        fn insert_relation(&self, finder: &mut ParentFinder) {
424            if let Some(this) = self {
425                this.insert_relation(finder);
426            }
427        }
428    }
429
430    /// A helper trait for easy implementation of the [`InsertRelation`].
431    ///
432    /// Lots of nodes in [`syn`]'s syntax tree wrapped in `Box`, `Option`, and others. This trait
433    /// unwraps those shells so that you can ignore their existence.
434    pub trait AsElements {
435        type Output<'a>: Iterator<Item = Node>
436        where
437            Self: 'a;
438
439        fn as_elements(&self) -> Self::Output<'_>;
440    }
441
442    impl<T: AsElements> AsElements for Option<T> {
443        type Output<'a>
444            = Elements<T::Output<'a>>
445        where
446            Self: 'a;
447
448        fn as_elements(&self) -> Self::Output<'_> {
449            if let Some(v) = self {
450                Elements::Iter(v.as_elements())
451            } else {
452                Elements::Empty
453            }
454        }
455    }
456
457    impl<T: AsElements> AsElements for Box<T> {
458        type Output<'a>
459            = T::Output<'a>
460        where
461            Self: 'a;
462
463        fn as_elements(&self) -> Self::Output<'_> {
464            (**self).as_elements()
465        }
466    }
467
468    impl<T: AsElements> AsElements for Vec<T> {
469        type Output<'a>
470            = Flatten<'a, slice::Iter<'a, T>, T>
471        where
472            Self: 'a;
473
474        fn as_elements(&self) -> Self::Output<'_> {
475            Flatten {
476                iters: self.iter(),
477                nodes: None,
478            }
479        }
480    }
481
482    impl<T: AsElements, P> AsElements for syn::punctuated::Punctuated<T, P> {
483        type Output<'a>
484            = Flatten<'a, punctuated::Iter<'a, T>, T>
485        where
486            Self: 'a;
487
488        fn as_elements(&self) -> Self::Output<'_> {
489            Flatten {
490                iters: self.iter(),
491                nodes: None,
492            }
493        }
494    }
495
496    impl<T0, T1> AsElements for (T0, T1)
497    where
498        T0: AsElements,
499        T1: AsElements,
500    {
501        type Output<'a>
502            = iter::Chain<T0::Output<'a>, T1::Output<'a>>
503        where
504            Self: 'a;
505
506        fn as_elements(&self) -> Self::Output<'_> {
507            self.0.as_elements().chain(self.1.as_elements())
508        }
509    }
510
511    impl<T0, T1, T2> AsElements for (T0, T1, T2)
512    where
513        T0: AsElements,
514        T1: AsElements,
515        T2: AsElements,
516    {
517        type Output<'a>
518            = iter::Chain<iter::Chain<T0::Output<'a>, T1::Output<'a>>, T2::Output<'a>>
519        where
520            Self: 'a;
521
522        fn as_elements(&self) -> Self::Output<'_> {
523            self.0
524                .as_elements()
525                .chain(self.1.as_elements())
526                .chain(self.2.as_elements())
527        }
528    }
529
530    pub enum Elements<I> {
531        Iter(I),
532        Empty,
533    }
534
535    impl<I: Iterator<Item = Node>> Iterator for Elements<I> {
536        type Item = Node;
537
538        fn next(&mut self) -> Option<Self::Item> {
539            match self {
540                Self::Iter(iter) => iter.next(),
541                Self::Empty => None,
542            }
543        }
544    }
545
546    pub struct Flatten<'a, I, T: AsElements + 'a> {
547        iters: I,
548        nodes: Option<T::Output<'a>>,
549    }
550
551    impl<'a, I, T> Iterator for Flatten<'a, I, T>
552    where
553        I: Iterator<Item = &'a T>,
554        T: AsElements + 'a,
555    {
556        type Item = Node;
557
558        fn next(&mut self) -> Option<Self::Item> {
559            if let Some(nodes) = self.nodes.as_mut() {
560                let node = nodes.next();
561                if node.is_some() {
562                    return node;
563                }
564            }
565
566            for next in self.iters.by_ref() {
567                let mut nodes = next.as_elements();
568                let node = nodes.next();
569                if node.is_some() {
570                    self.nodes = Some(nodes);
571                    return node;
572                }
573            }
574
575            None
576        }
577    }
578
579    #[derive(Clone, Copy)]
580    pub struct Node {
581        sid: SynId,
582        ptr_rel: *const dyn InsertRelation,
583    }
584
585    impl Node {
586        #[inline]
587        pub fn from<T: IdentifySyn + InsertRelation>(t: &T) -> Self {
588            Self {
589                sid: t.syn_id(),
590                ptr_rel: t as *const T as *const dyn InsertRelation,
591            }
592        }
593
594        pub const fn syn_id(&self) -> SynId {
595            self.sid
596        }
597
598        pub fn as_dyn_insert_relation(&self) -> &dyn InsertRelation {
599            unsafe { self.ptr_rel.as_ref().unwrap() }
600        }
601    }
602}
603
604mod find_children {
605    use crate::syntax::common::SynId;
606    use std::any::TypeId;
607
608    pub trait FindChildren {
609        /// Visits all descendants having the given types.
610        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F);
611    }
612
613    impl<T: FindChildren> FindChildren for Vec<T> {
614        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
615            for elem in self {
616                elem.visit_descendant(descendant_types, f);
617            }
618        }
619    }
620
621    impl<T: FindChildren, P> FindChildren for syn::punctuated::Punctuated<T, P> {
622        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
623            for elem in self {
624                elem.visit_descendant(descendant_types, f);
625            }
626        }
627    }
628
629    impl<T: FindChildren> FindChildren for Option<T> {
630        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
631            if let Some(inner) = self {
632                inner.visit_descendant(descendant_types, f);
633            }
634        }
635    }
636
637    impl<T: FindChildren> FindChildren for Box<T> {
638        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
639            (**self).visit_descendant(descendant_types, f);
640        }
641    }
642
643    impl<T0, T1> FindChildren for (T0, T1)
644    where
645        T0: FindChildren,
646        T1: FindChildren,
647    {
648        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
649            self.0.visit_descendant(descendant_types, f);
650            self.1.visit_descendant(descendant_types, f);
651        }
652    }
653
654    impl<T0, T1, T2> FindChildren for (T0, T1, T2)
655    where
656        T0: FindChildren,
657        T1: FindChildren,
658        T2: FindChildren,
659    {
660        fn visit_descendant<F: FnMut(usize, SynId)>(&self, descendant_types: &[TypeId], f: &mut F) {
661            self.0.visit_descendant(descendant_types, f);
662            self.1.visit_descendant(descendant_types, f);
663            self.2.visit_descendant(descendant_types, f);
664        }
665    }
666}
667
668/// Implements traits in [`identify`], [`find_parent`], and [`find_children`] for all syn items.
669mod impls {
670    use super::{
671        find_children::FindChildren,
672        find_parent::{AsElements, Elements, InsertRelation, Node, ParentFinder},
673        identify::IdentifySyn,
674    };
675    use std::{any::Any, iter};
676
677    macro_rules! impl_identify_syn {
678        ($ty:ty) => {
679            impl IdentifySyn for $ty {
680                fn as_any(&self) -> &dyn Any {
681                    self
682                }
683
684                fn type_name(&self) -> &'static str {
685                    std::any::type_name::<$ty>()
686                }
687            }
688        };
689    }
690
691    macro_rules! impl_as_elements {
692        ($ty:ty) => {
693            impl AsElements for $ty {
694                type Output<'a>
695                    = Elements<iter::Once<Node>>
696                where
697                    Self: 'a;
698
699                fn as_elements(&self) -> Self::Output<'_> {
700                    let node = Node::from(self);
701                    Elements::Iter(iter::once(node))
702                }
703            }
704        };
705    }
706
707    macro_rules! impl_insert_relation_simple {
708        ($ty:ty $(, $($fields:ident),* )?) => {
709            impl InsertRelation for $ty {
710                #[allow(unused_variables)]
711                fn insert_relation(&self, finder: &mut ParentFinder) {
712                    let parent = self.syn_id();
713                    $($(
714                        for child in self.$fields.as_elements() {
715                            let child: Node = child;
716                            finder.insert(child.syn_id(), parent);
717                            child.as_dyn_insert_relation()
718                                .insert_relation(finder);
719                        }
720                    )*)?
721                }
722            }
723        };
724    }
725
726    macro_rules! impl_insert_relation_match {
727        (
728            $ty:ty
729            $(, $( $arms:pat => { $($fields:ident),* } )* )?
730        ) =>
731        {
732            impl InsertRelation for $ty {
733                #[allow(unreachable_patterns, unused_variables)]
734                fn insert_relation(&self, finder: &mut ParentFinder) {
735                    let parent = self.syn_id();
736                    match self {
737                        $($(
738                            $arms => {
739                                $(
740                                    finder.insert($fields.syn_id(), parent);
741                                    $fields.insert_relation(finder);
742                                )*
743                            }
744                        )*)?
745                        _ => {}
746                    }
747                }
748            }
749        };
750    }
751
752    macro_rules! impl_find_children_simple {
753        ($ty:ty $(, $($fields:ident),* )?) => {
754            impl FindChildren for $ty {
755                fn visit_descendant<F: FnMut(usize, super::identify::SynId)>(
756                    &self,
757                    descendant_types: &[std::any::TypeId],
758                    f: &mut F
759                ) {
760                    if let Some((i, _)) = descendant_types
761                        .iter()
762                        .enumerate()
763                        .find(|(_, descendant)| **descendant == std::any::TypeId::of::<Self>())
764                    {
765                        f(i, self.syn_id());
766                    }
767
768                    $($(
769                        self.$fields.visit_descendant(descendant_types, f);
770                    )*)?
771                }
772            }
773        };
774    }
775
776    macro_rules! impl_find_children_match {
777        (
778            $ty:ty
779            $(, $( $arms:pat => { $($fields:ident),* } )* )?
780        ) =>
781        {
782            impl FindChildren for $ty {
783                #[allow(unreachable_patterns, unused_variables)]
784                fn visit_descendant<F: FnMut(usize, super::identify::SynId)>(
785                    &self,
786                    descendant_types: &[std::any::TypeId],
787                    f: &mut F,
788                ) {
789                    if let Some((i, _)) = descendant_types
790                        .iter()
791                        .enumerate()
792                        .find(|(_, descendant)| **descendant == std::any::TypeId::of::<Self>())
793                    {
794                        f(i, self.syn_id());
795                    }
796
797                    match self {
798                        $($(
799                            $arms => {
800                                $(
801                                    $fields.visit_descendant(descendant_types, f);
802                                )*
803                            }
804                        )*)?
805                        _ => {}
806                    }
807                }
808            }
809        };
810    }
811
812    macro_rules! impl_all_simple {
813        ($ty:ty $(, $($fields:ident),* )?) => {
814            impl_identify_syn!($ty);
815            impl_as_elements!($ty);
816            impl_insert_relation_simple!($ty $(, $($fields),* )?);
817            impl_find_children_simple!($ty $(, $($fields),* )?);
818        };
819    }
820
821    macro_rules! impl_all_match {
822        (
823            $ty:ty
824            $(, $( $arms:pat => { $($fields:ident),* } )* )?) =>
825        {
826            impl_identify_syn!($ty);
827            impl_as_elements!($ty);
828            impl_insert_relation_match!($ty $(,$( $arms => { $($fields),* } )*)?);
829            impl_find_children_match!($ty $(,$( $arms => { $($fields),* } )*)?);
830        };
831    }
832
833    // === Implement for this crate ===
834
835    impl_all_simple!(crate::syntax::file::File, file);
836
837    // === Implement for syn ===
838
839    impl_all_simple!(syn::Token![abstract]);
840    impl_all_simple!(syn::Token![as]);
841    impl_all_simple!(syn::Token![async]);
842    impl_all_simple!(syn::Token![auto]);
843    impl_all_simple!(syn::Token![await]);
844    impl_all_simple!(syn::Token![become]);
845    impl_all_simple!(syn::Token![box]);
846    impl_all_simple!(syn::Token![break]);
847    impl_all_simple!(syn::Token![const]);
848    impl_all_simple!(syn::Token![continue]);
849    impl_all_simple!(syn::Token![crate]);
850    impl_all_simple!(syn::Token![default]);
851    impl_all_simple!(syn::Token![do]);
852    impl_all_simple!(syn::Token![dyn]);
853    impl_all_simple!(syn::Token![else]);
854    impl_all_simple!(syn::Token![enum]);
855    impl_all_simple!(syn::Token![extern]);
856    impl_all_simple!(syn::Token![final]);
857    impl_all_simple!(syn::Token![fn]);
858    impl_all_simple!(syn::Token![for]);
859    impl_all_simple!(syn::Token![if]);
860    impl_all_simple!(syn::Token![impl]);
861    impl_all_simple!(syn::Token![in]);
862    impl_all_simple!(syn::Token![let]);
863    impl_all_simple!(syn::Token![loop]);
864    impl_all_simple!(syn::Token![macro]);
865    impl_all_simple!(syn::Token![match]);
866    impl_all_simple!(syn::Token![mod]);
867    impl_all_simple!(syn::Token![move]);
868    impl_all_simple!(syn::Token![mut]);
869    impl_all_simple!(syn::Token![override]);
870    impl_all_simple!(syn::Token![priv]);
871    impl_all_simple!(syn::Token![pub]);
872    impl_all_simple!(syn::Token![raw]);
873    impl_all_simple!(syn::Token![ref]);
874    impl_all_simple!(syn::Token![return]);
875    impl_all_simple!(syn::Token![Self]);
876    impl_all_simple!(syn::Token![self]);
877    impl_all_simple!(syn::Token![static]);
878    impl_all_simple!(syn::Token![struct]);
879    impl_all_simple!(syn::Token![super]);
880    impl_all_simple!(syn::Token![trait]);
881    impl_all_simple!(syn::Token![try]);
882    impl_all_simple!(syn::Token![type]);
883    impl_all_simple!(syn::Token![typeof]);
884    impl_all_simple!(syn::Token![union]);
885    impl_all_simple!(syn::Token![unsafe]);
886    impl_all_simple!(syn::Token![unsized]);
887    impl_all_simple!(syn::Token![use]);
888    impl_all_simple!(syn::Token![virtual]);
889    impl_all_simple!(syn::Token![where]);
890    impl_all_simple!(syn::Token![while]);
891    impl_all_simple!(syn::Token![yield]);
892    impl_all_simple!(syn::Token![&]);
893    impl_all_simple!(syn::Token![&&]);
894    impl_all_simple!(syn::Token![&=]);
895    impl_all_simple!(syn::Token![@]);
896    impl_all_simple!(syn::Token![^]);
897    impl_all_simple!(syn::Token![^=]);
898    impl_all_simple!(syn::Token![:]);
899    impl_all_simple!(syn::Token![,]);
900    impl_all_simple!(syn::Token![$]);
901    impl_all_simple!(syn::Token![.]);
902    impl_all_simple!(syn::Token![..]);
903    impl_all_simple!(syn::Token![...]);
904    impl_all_simple!(syn::Token![..=]);
905    impl_all_simple!(syn::Token![=]);
906    impl_all_simple!(syn::Token![==]);
907    impl_all_simple!(syn::Token![=>]);
908    impl_all_simple!(syn::Token![>=]);
909    impl_all_simple!(syn::Token![>]);
910    impl_all_simple!(syn::Token![<-]);
911    impl_all_simple!(syn::Token![<=]);
912    impl_all_simple!(syn::Token![<]);
913    impl_all_simple!(syn::Token![-]);
914    impl_all_simple!(syn::Token![-=]);
915    impl_all_simple!(syn::Token![!=]);
916    impl_all_simple!(syn::Token![!]);
917    impl_all_simple!(syn::Token![|]);
918    impl_all_simple!(syn::Token![|=]);
919    impl_all_simple!(syn::Token![||]);
920    impl_all_simple!(syn::Token![::]);
921    impl_all_simple!(syn::Token![%]);
922    impl_all_simple!(syn::Token![%=]);
923    impl_all_simple!(syn::Token![+]);
924    impl_all_simple!(syn::Token![+=]);
925    impl_all_simple!(syn::Token![#]);
926    impl_all_simple!(syn::Token![?]);
927    impl_all_simple!(syn::Token![->]);
928    impl_all_simple!(syn::Token![;]);
929    impl_all_simple!(syn::Token![<<]);
930    impl_all_simple!(syn::Token![<<=]);
931    impl_all_simple!(syn::Token![>>]);
932    impl_all_simple!(syn::Token![>>=]);
933    impl_all_simple!(syn::Token![/]);
934    impl_all_simple!(syn::Token![/=]);
935    impl_all_simple!(syn::Token![*]);
936    impl_all_simple!(syn::Token![*=]);
937    impl_all_simple!(syn::Token![~]);
938    impl_all_simple!(syn::Token![_]);
939    impl_all_simple!(syn::token::Group);
940    impl_all_simple!(syn::token::Brace);
941    impl_all_simple!(syn::token::Bracket);
942    impl_all_simple!(syn::token::Paren);
943    impl_all_simple!(syn::Abi, extern_token, name);
944    impl_all_simple!(
945        syn::AngleBracketedGenericArguments,
946        colon2_token,
947        lt_token,
948        args,
949        gt_token
950    );
951    impl_all_simple!(syn::Arm, attrs, pat, guard, fat_arrow_token, body, comma);
952    impl_all_simple!(syn::AssocConst, ident, generics, eq_token, value);
953    impl_all_simple!(syn::AssocType, ident, generics, eq_token, ty);
954    impl_all_simple!(syn::Attribute, pound_token, style, bracket_token, meta);
955    impl_all_match!(
956        syn::AttrStyle,
957        Self::Outer => {}
958        Self::Inner(v) => {v}
959    );
960    impl_all_simple!(syn::BareFnArg, attrs, name, ty);
961    impl_all_simple!(syn::BareVariadic, attrs, name, dots, comma);
962    impl_all_match!(
963        syn::BinOp,
964        Self::Add(v) => {v}
965        Self::Sub(v) => {v}
966        Self::Mul(v) => {v}
967        Self::Div(v) => {v}
968        Self::Rem(v) => {v}
969        Self::And(v) => {v}
970        Self::Or(v) => {v}
971        Self::BitXor(v) => {v}
972        Self::BitAnd(v) => {v}
973        Self::BitOr(v) => {v}
974        Self::Shl(v) => {v}
975        Self::Shr(v) => {v}
976        Self::Eq(v) => {v}
977        Self::Lt(v) => {v}
978        Self::Le(v) => {v}
979        Self::Ne(v) => {v}
980        Self::Ge(v) => {v}
981        Self::Gt(v) => {v}
982        Self::AddAssign(v) => {v}
983        Self::SubAssign(v) => {v}
984        Self::MulAssign(v) => {v}
985        Self::DivAssign(v) => {v}
986        Self::RemAssign(v) => {v}
987        Self::BitXorAssign(v) => {v}
988        Self::BitAndAssign(v) => {v}
989        Self::BitOrAssign(v) => {v}
990        Self::ShlAssign(v) => {v}
991        Self::ShrAssign(v) => {v}
992    );
993    impl_all_simple!(syn::Block, brace_token, stmts);
994    impl_all_simple!(
995        syn::BoundLifetimes,
996        for_token,
997        lt_token,
998        lifetimes,
999        gt_token
1000    );
1001    impl_all_match!(
1002        syn::CapturedParam,
1003        Self::Lifetime(v) => {v}
1004        Self::Ident(v) => {v}
1005    );
1006    impl_all_simple!(
1007        syn::ConstParam,
1008        attrs,
1009        const_token,
1010        ident,
1011        colon_token,
1012        ty,
1013        eq_token,
1014        default
1015    );
1016    impl_all_simple!(syn::Constraint, ident, generics, colon_token, bounds);
1017    impl_all_match!(
1018        syn::Expr,
1019        Self::Array(v) => {v}
1020        Self::Assign(v) => {v}
1021        Self::Async(v) => {v}
1022        Self::Await(v) => {v}
1023        Self::Binary(v) => {v}
1024        Self::Block(v) => {v}
1025        Self::Break(v) => {v}
1026        Self::Call(v) => {v}
1027        Self::Cast(v) => {v}
1028        Self::Closure(v) => {v}
1029        Self::Const(v) => {v}
1030        Self::Continue(v) => {v}
1031        Self::Field(v) => {v}
1032        Self::ForLoop(v) => {v}
1033        Self::Group(v) => {v}
1034        Self::If(v) => {v}
1035        Self::Index(v) => {v}
1036        Self::Infer(v) => {v}
1037        Self::Let(v) => {v}
1038        Self::Lit(v) => {v}
1039        Self::Loop(v) => {v}
1040        Self::Macro(v) => {v}
1041        Self::Match(v) => {v}
1042        Self::MethodCall(v) => {v}
1043        Self::Paren(v) => {v}
1044        Self::Path(v) => {v}
1045        Self::Range(v) => {v}
1046        Self::RawAddr(v) => {v}
1047        Self::Reference(v) => {v}
1048        Self::Repeat(v) => {v}
1049        Self::Return(v) => {v}
1050        Self::Struct(v) => {v}
1051        Self::Try(v) => {v}
1052        Self::TryBlock(v) => {v}
1053        Self::Tuple(v) => {v}
1054        Self::Unary(v) => {v}
1055        Self::Unsafe(v) => {v}
1056        Self::Verbatim(_) => {}
1057        Self::While(v) => {v}
1058        Self::Yield(v) => {v}
1059    );
1060    impl_all_simple!(syn::ExprArray, attrs, bracket_token, elems);
1061    impl_all_simple!(syn::ExprAssign, attrs, left, eq_token, right);
1062    impl_all_simple!(syn::ExprAsync, attrs, async_token, capture, block);
1063    impl_all_simple!(syn::ExprAwait, attrs, base, dot_token, await_token);
1064    impl_all_simple!(syn::ExprBinary, attrs, left, op, right);
1065    impl_all_simple!(syn::ExprBlock, attrs, label, block);
1066    impl_all_simple!(syn::ExprBreak, attrs, break_token, label, expr);
1067    impl_all_simple!(syn::ExprCall, attrs, func, paren_token, args);
1068    impl_all_simple!(syn::ExprCast, attrs, expr, as_token, ty);
1069    impl_all_simple!(
1070        syn::ExprClosure,
1071        attrs,
1072        lifetimes,
1073        constness,
1074        movability,
1075        asyncness,
1076        capture,
1077        or1_token,
1078        inputs,
1079        or2_token,
1080        output,
1081        body
1082    );
1083    impl_all_simple!(syn::ExprConst, attrs, const_token, block);
1084    impl_all_simple!(syn::ExprContinue, attrs, continue_token, label);
1085    impl_all_simple!(syn::ExprField, attrs, base, dot_token, member);
1086    impl_all_simple!(
1087        syn::ExprForLoop,
1088        attrs,
1089        label,
1090        for_token,
1091        pat,
1092        in_token,
1093        expr,
1094        body
1095    );
1096    impl_all_simple!(syn::ExprGroup, attrs, group_token, expr);
1097    impl_all_simple!(syn::ExprIf, attrs, if_token, cond, then_branch, else_branch);
1098    impl_all_simple!(syn::ExprIndex, attrs, expr, bracket_token, index);
1099    impl_all_simple!(syn::ExprInfer, attrs, underscore_token);
1100    impl_all_simple!(syn::ExprLet, attrs, let_token, pat, eq_token, expr);
1101    impl_all_simple!(syn::ExprLit, attrs, lit);
1102    impl_all_simple!(syn::ExprLoop, attrs, label, loop_token, body);
1103    impl_all_simple!(syn::ExprMacro, attrs, mac);
1104    impl_all_simple!(syn::ExprMatch, attrs, match_token, expr, brace_token, arms);
1105    impl_all_simple!(
1106        syn::ExprMethodCall,
1107        attrs,
1108        receiver,
1109        dot_token,
1110        method,
1111        turbofish,
1112        paren_token,
1113        args
1114    );
1115    impl_all_simple!(syn::ExprParen, attrs, paren_token, expr);
1116    impl_all_simple!(syn::ExprPath, attrs, qself, path);
1117    impl_all_simple!(syn::ExprRange, attrs, start, limits, end);
1118    impl_all_simple!(syn::ExprRawAddr, attrs, and_token, raw, mutability, expr);
1119    impl_all_simple!(syn::ExprReference, attrs, and_token, mutability, expr);
1120    impl_all_simple!(syn::ExprRepeat, attrs, bracket_token, expr, len);
1121    impl_all_simple!(syn::ExprReturn, attrs, return_token, expr);
1122    impl_all_simple!(
1123        syn::ExprStruct,
1124        attrs,
1125        qself,
1126        path,
1127        brace_token,
1128        fields,
1129        dot2_token,
1130        rest
1131    );
1132    impl_all_simple!(syn::ExprTry, attrs, expr, question_token);
1133    impl_all_simple!(syn::ExprTryBlock, attrs, try_token, block);
1134    impl_all_simple!(syn::ExprTuple, attrs, paren_token, elems);
1135    impl_all_simple!(syn::ExprUnary, attrs, op, expr);
1136    impl_all_simple!(syn::ExprUnsafe, attrs, unsafe_token, block);
1137    impl_all_simple!(syn::ExprWhile, attrs, label, while_token, cond, body);
1138    impl_all_simple!(syn::ExprYield, attrs, yield_token, expr);
1139    impl_all_simple!(syn::Field, attrs, vis, mutability, ident, colon_token, ty);
1140    impl_all_match!(
1141        syn::FieldMutability,
1142        Self::None => {}
1143    );
1144    impl_all_simple!(syn::FieldPat, attrs, member, colon_token, pat);
1145    impl_all_match!(
1146        syn::Fields,
1147        Self::Named(v) => {v}
1148        Self::Unnamed(v) => {v}
1149        Self::Unit => {}
1150    );
1151    impl_all_simple!(syn::FieldsNamed, brace_token, named);
1152    impl_all_simple!(syn::FieldsUnnamed, paren_token, unnamed);
1153    impl_all_simple!(syn::FieldValue, attrs, member, colon_token, expr);
1154    impl_all_simple!(syn::File, /*shebang*/ attrs, items);
1155    impl_all_match!(
1156        syn::FnArg,
1157        Self::Receiver(v) => {v}
1158        Self::Typed(v) => {v}
1159    );
1160    impl_all_match!(
1161        syn::ForeignItem,
1162        Self::Fn(v) => {v}
1163        Self::Static(v) => {v}
1164        Self::Type(v) => {v}
1165        Self::Macro(v) => {v}
1166        Self::Verbatim(_) => {}
1167    );
1168    impl_all_simple!(syn::ForeignItemFn, attrs, vis, sig, semi_token);
1169    impl_all_simple!(
1170        syn::ForeignItemStatic,
1171        attrs,
1172        vis,
1173        static_token,
1174        mutability,
1175        ident,
1176        colon_token,
1177        ty,
1178        semi_token
1179    );
1180    impl_all_simple!(
1181        syn::ForeignItemType,
1182        attrs,
1183        vis,
1184        type_token,
1185        ident,
1186        generics,
1187        semi_token
1188    );
1189    impl_all_simple!(syn::ForeignItemMacro, attrs, mac, semi_token);
1190    impl_all_match!(
1191        syn::GenericArgument,
1192        Self::Lifetime(v) => {v}
1193        Self::Type(v) => {v}
1194        Self::Const(v) => {v}
1195        Self::AssocType(v) => {v}
1196        Self::AssocConst(v) => {v}
1197        Self::Constraint(v) => {v}
1198    );
1199    impl_all_match!(
1200        syn::GenericParam,
1201        Self::Lifetime(v) => {v}
1202        Self::Type(v) => {v}
1203        Self::Const(v) => {v}
1204    );
1205    impl_all_simple!(syn::Generics, lt_token, params, gt_token, where_clause);
1206    impl_all_simple!(syn::Ident);
1207    impl_all_match!(
1208        syn::ImplItem,
1209        Self::Const(v) => {v}
1210        Self::Fn(v) => {v}
1211        Self::Type(v) => {v}
1212        Self::Macro(v) => {v}
1213        Self::Verbatim(_) => {}
1214    );
1215    impl_all_simple!(
1216        syn::ImplItemConst,
1217        attrs,
1218        vis,
1219        defaultness,
1220        const_token,
1221        ident,
1222        generics,
1223        colon_token,
1224        ty,
1225        eq_token,
1226        expr,
1227        semi_token
1228    );
1229    impl_all_simple!(syn::ImplItemFn, attrs, vis, defaultness, sig, block);
1230    impl_all_simple!(
1231        syn::ImplItemType,
1232        attrs,
1233        vis,
1234        defaultness,
1235        type_token,
1236        ident,
1237        generics,
1238        eq_token,
1239        ty,
1240        semi_token
1241    );
1242    impl_all_simple!(syn::ImplItemMacro, attrs, mac, semi_token);
1243    impl_all_match!(syn::ImplRestriction);
1244    impl_all_simple!(syn::Index);
1245    impl_all_match!(
1246        syn::Item,
1247        Self::Const(v) => {v}
1248        Self::Enum(v) => {v}
1249        Self::ExternCrate(v) => {v}
1250        Self::Fn(v) => {v}
1251        Self::ForeignMod(v) => {v}
1252        Self::Impl(v) => {v}
1253        Self::Macro(v) => {v}
1254        Self::Mod(v) => {v}
1255        Self::Static(v) => {v}
1256        Self::Struct(v) => {v}
1257        Self::Trait(v) => {v}
1258        Self::TraitAlias(v) => {v}
1259        Self::Type(v) => {v}
1260        Self::Union(v) => {v}
1261        Self::Use(v) => {v}
1262        Self::Verbatim(_) => {}
1263    );
1264    impl_all_simple!(
1265        syn::ItemConst,
1266        attrs,
1267        vis,
1268        const_token,
1269        ident,
1270        generics,
1271        colon_token,
1272        ty,
1273        eq_token,
1274        expr,
1275        semi_token
1276    );
1277    impl_all_simple!(
1278        syn::ItemEnum,
1279        attrs,
1280        vis,
1281        enum_token,
1282        ident,
1283        generics,
1284        brace_token,
1285        variants
1286    );
1287    impl_all_simple!(
1288        syn::ItemExternCrate,
1289        attrs,
1290        vis,
1291        extern_token,
1292        crate_token,
1293        ident,
1294        rename,
1295        semi_token
1296    );
1297    impl_all_simple!(syn::ItemFn, attrs, vis, sig, block);
1298    impl_all_simple!(
1299        syn::ItemForeignMod,
1300        attrs,
1301        unsafety,
1302        abi,
1303        brace_token,
1304        items
1305    );
1306    impl_all_simple!(
1307        syn::ItemImpl,
1308        attrs,
1309        defaultness,
1310        unsafety,
1311        impl_token,
1312        generics,
1313        trait_,
1314        self_ty,
1315        brace_token,
1316        items
1317    );
1318    impl_all_simple!(syn::ItemMacro, attrs, ident, mac, semi_token);
1319    impl_all_simple!(
1320        syn::ItemMod,
1321        attrs,
1322        vis,
1323        unsafety,
1324        mod_token,
1325        ident,
1326        content,
1327        semi
1328    );
1329    impl_all_simple!(
1330        syn::ItemStatic,
1331        attrs,
1332        vis,
1333        static_token,
1334        mutability,
1335        ident,
1336        colon_token,
1337        ty,
1338        eq_token,
1339        expr,
1340        semi_token
1341    );
1342    impl_all_simple!(
1343        syn::ItemStruct,
1344        attrs,
1345        vis,
1346        struct_token,
1347        ident,
1348        generics,
1349        fields,
1350        semi_token
1351    );
1352    impl_all_simple!(
1353        syn::ItemTrait,
1354        attrs,
1355        vis,
1356        unsafety,
1357        auto_token,
1358        restriction,
1359        trait_token,
1360        ident,
1361        generics,
1362        colon_token,
1363        supertraits,
1364        brace_token,
1365        items
1366    );
1367    impl_all_simple!(
1368        syn::ItemTraitAlias,
1369        attrs,
1370        vis,
1371        trait_token,
1372        ident,
1373        generics,
1374        eq_token,
1375        bounds,
1376        semi_token
1377    );
1378    impl_all_simple!(
1379        syn::ItemType,
1380        attrs,
1381        vis,
1382        type_token,
1383        ident,
1384        generics,
1385        eq_token,
1386        ty,
1387        semi_token
1388    );
1389    impl_all_simple!(
1390        syn::ItemUnion,
1391        attrs,
1392        vis,
1393        union_token,
1394        ident,
1395        generics,
1396        fields
1397    );
1398    impl_all_simple!(
1399        syn::ItemUse,
1400        attrs,
1401        vis,
1402        use_token,
1403        leading_colon,
1404        tree,
1405        semi_token
1406    );
1407    impl_all_simple!(syn::Label, name, colon_token);
1408    impl_all_simple!(syn::Lifetime, ident);
1409    impl_all_simple!(syn::LifetimeParam, attrs, lifetime, colon_token, bounds);
1410    impl_all_match!(
1411        syn::Lit,
1412        Self::Str(v) => {v}
1413        Self::ByteStr(v) => {v}
1414        Self::CStr(v) => {v}
1415        Self::Byte(v) => {v}
1416        Self::Char(v) => {v}
1417        Self::Int(v) => {v}
1418        Self::Float(v) => {v}
1419        Self::Bool(v) => {v}
1420        Self::Verbatim(_) => {}
1421    );
1422    impl_all_simple!(syn::LitStr);
1423    impl_all_simple!(syn::LitByteStr);
1424    impl_all_simple!(syn::LitCStr);
1425    impl_all_simple!(syn::LitByte);
1426    impl_all_simple!(syn::LitChar);
1427    impl_all_simple!(syn::LitInt);
1428    impl_all_simple!(syn::LitFloat);
1429    impl_all_simple!(syn::LitBool);
1430    impl_all_simple!(syn::Local, attrs, let_token, pat, init, semi_token);
1431    impl_all_simple!(syn::LocalInit, eq_token, expr, diverge);
1432    impl_all_simple!(syn::Macro, path, bang_token, delimiter);
1433    impl_all_match!(
1434        syn::MacroDelimiter,
1435        Self::Paren(v) => {v}
1436        Self::Brace(v) => {v}
1437        Self::Bracket(v) => {v}
1438    );
1439    impl_all_match!(
1440        syn::Member,
1441        Self::Named(v) => {v}
1442        Self::Unnamed(v) => {v}
1443    );
1444    impl_all_match!(
1445        syn::Meta,
1446        Self::Path(v) => {v}
1447        Self::List(v) => {v}
1448        Self::NameValue(v) => {v}
1449    );
1450    impl_all_simple!(syn::MetaList, path, delimiter);
1451    impl_all_simple!(syn::MetaNameValue, path, eq_token, value);
1452    impl_all_simple!(
1453        syn::ParenthesizedGenericArguments,
1454        paren_token,
1455        inputs,
1456        output
1457    );
1458    impl_all_match!(
1459        syn::Pat,
1460        Self::Const(v) => {v}
1461        Self::Ident(v) => {v}
1462        Self::Lit(v) => {v}
1463        Self::Macro(v) => {v}
1464        Self::Or(v) => {v}
1465        Self::Paren(v) => {v}
1466        Self::Path(v) => {v}
1467        Self::Range(v) => {v}
1468        Self::Reference(v) => {v}
1469        Self::Rest(v) => {v}
1470        Self::Slice(v) => {v}
1471        Self::Struct(v) => {v}
1472        Self::Tuple(v) => {v}
1473        Self::TupleStruct(v) => {v}
1474        Self::Type(v) => {v}
1475        Self::Verbatim(_) => {}
1476        Self::Wild(v) => {v}
1477    );
1478    impl_all_simple!(syn::PatIdent, attrs, by_ref, mutability, ident, subpat);
1479    impl_all_simple!(syn::PatOr, attrs, leading_vert, cases);
1480    impl_all_simple!(syn::PatParen, attrs, paren_token, pat);
1481    impl_all_simple!(syn::PatReference, attrs, and_token, mutability, pat);
1482    impl_all_simple!(syn::PatRest, attrs, dot2_token);
1483    impl_all_simple!(syn::PatSlice, attrs, bracket_token, elems);
1484    impl_all_simple!(
1485        syn::PatStruct,
1486        attrs,
1487        qself,
1488        path,
1489        brace_token,
1490        fields,
1491        rest
1492    );
1493    impl_all_simple!(syn::PatTuple, attrs, paren_token, elems);
1494    impl_all_simple!(syn::PatTupleStruct, attrs, qself, path, paren_token, elems);
1495    impl_all_simple!(syn::PatType, attrs, pat, colon_token, ty);
1496    impl_all_simple!(syn::PatWild, attrs, underscore_token);
1497    impl_all_simple!(syn::Path, leading_colon, segments);
1498    impl_all_match!(
1499        syn::PathArguments,
1500        Self::None => {}
1501        Self::AngleBracketed(v) => {v}
1502        Self::Parenthesized(v) => {v}
1503    );
1504    impl_all_simple!(syn::PathSegment, ident, arguments);
1505    impl_all_match!(
1506        syn::PointerMutability,
1507        Self::Const(v) => {v}
1508        Self::Mut(v) => {v}
1509    );
1510    impl_all_simple!(syn::PreciseCapture, use_token, lt_token, params, gt_token);
1511    impl_all_simple!(syn::PredicateLifetime, lifetime, colon_token, bounds);
1512    impl_all_simple!(
1513        syn::PredicateType,
1514        lifetimes,
1515        bounded_ty,
1516        colon_token,
1517        bounds
1518    );
1519    impl_all_simple!(
1520        syn::QSelf,
1521        lt_token,
1522        ty,
1523        /*position*/ as_token,
1524        gt_token
1525    );
1526    impl_all_match!(
1527        syn::RangeLimits,
1528        Self::HalfOpen(v) => {v}
1529        Self::Closed(v) => {v}
1530    );
1531    impl_all_simple!(
1532        syn::Receiver,
1533        attrs,
1534        reference,
1535        mutability,
1536        self_token,
1537        colon_token,
1538        ty
1539    );
1540    impl_all_match!(
1541        syn::ReturnType,
1542        Self::Default => {}
1543        Self::Type(arrow, ty) => {arrow, ty}
1544    );
1545    impl_all_simple!(
1546        syn::Signature,
1547        constness,
1548        asyncness,
1549        unsafety,
1550        abi,
1551        fn_token,
1552        ident,
1553        generics,
1554        paren_token,
1555        inputs,
1556        variadic,
1557        output
1558    );
1559    impl_all_match!(
1560        syn::StaticMutability,
1561        Self::Mut(v) => {v}
1562        Self::None => {}
1563    );
1564    impl_all_match!(
1565        syn::Stmt,
1566        Self::Local(v) => {v}
1567        Self::Item(v) => {v}
1568        Self::Expr(expr, Some(semi)) => {expr, semi}
1569        Self::Expr(expr, None) => {expr}
1570        Self::Macro(v) => {v}
1571    );
1572    impl_all_simple!(syn::StmtMacro, attrs, mac, semi_token);
1573    impl_all_simple!(syn::TraitBound, paren_token, modifier, lifetimes, path);
1574    impl_all_match!(
1575        syn::TraitBoundModifier,
1576        Self::None => {}
1577        Self::Maybe(v) => {v}
1578    );
1579    impl_all_match!(
1580        syn::TraitItem,
1581        Self::Const(v) => {v}
1582        Self::Fn(v) => {v}
1583        Self::Type(v) => {v}
1584        Self::Macro(v) => {v}
1585        Self::Verbatim(_) => {}
1586    );
1587    impl_all_simple!(
1588        syn::TraitItemConst,
1589        attrs,
1590        const_token,
1591        ident,
1592        generics,
1593        colon_token,
1594        ty,
1595        default,
1596        semi_token
1597    );
1598    impl_all_simple!(syn::TraitItemFn, attrs, sig, default, semi_token);
1599    impl_all_simple!(
1600        syn::TraitItemType,
1601        attrs,
1602        type_token,
1603        ident,
1604        generics,
1605        colon_token,
1606        bounds,
1607        default,
1608        semi_token
1609    );
1610    impl_all_simple!(syn::TraitItemMacro, attrs, mac, semi_token);
1611    impl_all_match!(
1612        syn::Type,
1613        Self::Array(v) => {v}
1614        Self::BareFn(v) => {v}
1615        Self::Group(v) => {v}
1616        Self::ImplTrait(v) => {v}
1617        Self::Infer(v) => {v}
1618        Self::Macro(v) => {v}
1619        Self::Never(v) => {v}
1620        Self::Paren(v) => {v}
1621        Self::Path(v) => {v}
1622        Self::Ptr(v) => {v}
1623        Self::Reference(v) => {v}
1624        Self::Slice(v) => {v}
1625        Self::TraitObject(v) => {v}
1626        Self::Tuple(v) => {v}
1627        Self::Verbatim(_) => {}
1628    );
1629    impl_all_simple!(syn::TypeArray, bracket_token, elem, semi_token, len);
1630    impl_all_simple!(
1631        syn::TypeBareFn,
1632        lifetimes,
1633        unsafety,
1634        abi,
1635        fn_token,
1636        paren_token,
1637        inputs,
1638        variadic,
1639        output
1640    );
1641    impl_all_simple!(syn::TypeGroup, group_token, elem);
1642    impl_all_simple!(syn::TypeImplTrait, impl_token, bounds);
1643    impl_all_simple!(syn::TypeInfer, underscore_token);
1644    impl_all_simple!(syn::TypeMacro, mac);
1645    impl_all_simple!(syn::TypeNever, bang_token);
1646    impl_all_simple!(syn::TypeParen, paren_token, elem);
1647    impl_all_simple!(syn::TypePath, qself, path);
1648    impl_all_simple!(syn::TypePtr, star_token, const_token, mutability, elem);
1649    impl_all_simple!(syn::TypeReference, and_token, lifetime, mutability, elem);
1650    impl_all_simple!(syn::TypeSlice, bracket_token, elem);
1651    impl_all_simple!(syn::TypeTraitObject, dyn_token, bounds);
1652    impl_all_simple!(syn::TypeTuple, paren_token, elems);
1653    impl_all_simple!(
1654        syn::TypeParam,
1655        attrs,
1656        ident,
1657        colon_token,
1658        bounds,
1659        eq_token,
1660        default
1661    );
1662    impl_all_match!(
1663        syn::TypeParamBound,
1664        Self::Trait(v) => {v}
1665        Self::Lifetime(v) => {v}
1666        Self::PreciseCapture(v) => {v}
1667        Self::Verbatim(_) => {}
1668    );
1669    impl_all_match!(
1670        syn::UnOp,
1671        Self::Deref(v) => {v}
1672        Self::Not(v) => {v}
1673        Self::Neg(v) => {v}
1674    );
1675    impl_all_simple!(syn::UseGlob, star_token);
1676    impl_all_simple!(syn::UseGroup, brace_token, items);
1677    impl_all_simple!(syn::UseName, ident);
1678    impl_all_simple!(syn::UsePath, ident, colon2_token, tree);
1679    impl_all_simple!(syn::UseRename, ident, as_token, rename);
1680    impl_all_match!(
1681        syn::UseTree,
1682        Self::Path(v) => {v}
1683        Self::Name(v) => {v}
1684        Self::Rename(v) => {v}
1685        Self::Glob(v) => {v}
1686        Self::Group(v) => {v}
1687    );
1688    impl_all_simple!(syn::Variadic, attrs, pat, dots, comma);
1689    impl_all_simple!(syn::Variant, attrs, ident, fields, discriminant);
1690    impl_all_match!(
1691        syn::Visibility,
1692        Self::Public(v) => {v}
1693        Self::Restricted(v) => {v}
1694        Self::Inherited => {}
1695    );
1696    impl_all_simple!(syn::VisRestricted, pub_token, paren_token, in_token, path);
1697    impl_all_simple!(syn::WhereClause, where_token, predicates);
1698    impl_all_match!(
1699        syn::WherePredicate,
1700        Self::Lifetime(v) => {v}
1701        Self::Type(v) => {v}
1702    );
1703}
syn_sem/syntax/common.rs

syn_sem/syntax/
common.rs
