swc_macros_common/derive/
generics.rs

1use std::collections::BTreeSet;
2
3use quote::quote;
4use syn::visit::Visit;
5
6use super::*;
7
8impl<'a> Derive<'a> {
9    pub fn all_generic_fields(&self) -> Vec<&'a Field> {
10        struct TypeVisitor<'a> {
11            params: &'a BTreeSet<Ident>,
12            is_generic: bool,
13        }
14
15        impl Visit<'_> for TypeVisitor<'_> {
16            fn visit_path(&mut self, path: &Path) {
17                if let Some(seg) = path.segments.last() {
18                    if seg.ident == "PhantomData" {
19                        // Hardcoded exception.
20                        // This assumes name of the associated type is not PhantomData.
21                        return;
22                    }
23                }
24
25                if path.leading_colon.is_none() {
26                    if let Some(seg) = path.segments.first() {
27                        let id = &seg.ident;
28                        if self.params.contains(id) {
29                            self.is_generic = true;
30                        }
31                    }
32                }
33
34                visit::visit_path(self, path)
35            }
36
37            fn visit_macro(&mut self, _: &Macro) {}
38        }
39
40        struct FieldVisitor<'a> {
41            /// Type parameters defined on type.
42            params: BTreeSet<Ident>,
43            fields: Vec<&'a Field>,
44        }
45
46        impl<'a: 'b, 'b> Visit<'a> for FieldVisitor<'b> {
47            fn visit_field(&mut self, field: &'a Field) {
48                let mut vis = TypeVisitor {
49                    params: &self.params,
50                    is_generic: false,
51                };
52                vis.visit_type(&field.ty);
53                if vis.is_generic {
54                    self.fields.push(field);
55                }
56            }
57        }
58
59        let mut vis = FieldVisitor {
60            params: self
61                .input
62                .generics
63                .params
64                .iter()
65                .filter_map(|p| match *p {
66                    GenericParam::Type(TypeParam { ref ident, .. }) => Some(ident.clone()),
67                    _ => None,
68                })
69                .collect(),
70            fields: Vec::new(),
71        };
72
73        vis.visit_derive_input(self.input);
74        vis.fields
75    }
76
77    pub fn add_where_predicates<I>(&mut self, preds: I)
78    where
79        I: IntoIterator<Item = WherePredicate>,
80    {
81        let preds = preds
82            .into_iter()
83            .map(|t| Pair::Punctuated(t, Token![,](def_site())));
84
85        match self.out.generics.where_clause {
86            Some(WhereClause {
87                ref mut predicates, ..
88            }) => {
89                if !predicates.empty_or_trailing() {
90                    predicates.push_punct(Token![,](def_site()));
91                }
92
93                predicates.extend(preds)
94            }
95            None => {
96                self.out.generics.where_clause = Some(WhereClause {
97                    where_token: Token![where](def_site()),
98                    predicates: preds.collect(),
99                })
100            }
101        }
102    }
103
104    /// Add `Self: #trait_`.
105    pub fn bound_self(&mut self, trait_: Path) {
106        let self_ty: Type = parse(quote!(Self).into()).unwrap();
107
108        let bound = WherePredicate::Type(PredicateType {
109            lifetimes: None,
110            bounded_ty: self_ty,
111            colon_token: Token![:](def_site()),
112            // `Trait` in `Self: Trait`
113            bounds: iter::once(Pair::End(TypeParamBound::Trait(TraitBound {
114                modifier: TraitBoundModifier::None,
115                lifetimes: None,
116                path: trait_,
117                paren_token: None,
118            })))
119            .collect(),
120        });
121
122        self.add_where_predicates(iter::once(bound))
123    }
124}
swc_macros_common/derive/generics.rs

swc_macros_common/derive/
generics.rs
