gdnative-derive 0.11.3

The Godot game engine's gdnative derive and procedural macros.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::collections::HashSet;

use syn::spanned::Spanned;
use syn::visit::{self, Visit};
use syn::{Generics, Ident, Type, TypePath};

// recursively visit all the field types to find what types should be bounded
pub struct BoundsVisitor<'ast> {
    all_type_params: HashSet<Ident>,
    used: HashSet<&'ast TypePath>,
}

impl<'ast> Visit<'ast> for BoundsVisitor<'ast> {
    fn visit_type_path(&mut self, type_path: &'ast TypePath) {
        let path = &type_path.path;
        if let Some(seg) = path.segments.last() {
            if seg.ident == "PhantomData" {
                // things inside PhantomDatas doesn't need to be bounded, so stopping
                // recursive visit here
                return;
            }
        }
        if let Some(seg) = path.segments.first() {
            if self.all_type_params.contains(&seg.ident) {
                // if the first segment of the type path is a known type variable, then this
                // is likely an associated type
                self.used.insert(type_path);
            }
        }
        visit::visit_path(self, &type_path.path);
    }
}

impl<'ast> BoundsVisitor<'ast> {
    fn new(generics: &Generics) -> Self {
        let all_type_params = generics
            .type_params()
            .map(|param| param.ident.clone())
            .collect();

        BoundsVisitor {
            all_type_params,
            used: HashSet::new(),
        }
    }
}

pub fn with_visitor<'ast, F>(
    generics: Generics,
    bound: Option<&syn::Path>,
    lifetime: Option<&str>,
    op: F,
) -> Generics
where
    F: FnOnce(&mut BoundsVisitor<'ast>),
{
    let mut visitor = BoundsVisitor::new(&generics);

    op(&mut visitor);

    // where thing: is_trait
    fn where_predicate(
        thing: Type,
        bound: Option<&syn::Path>,
        lifetime: Option<&str>,
    ) -> syn::WherePredicate {
        let mut bounds = vec![];

        if let Some(bound) = bound {
            bounds.push(syn::TypeParamBound::Trait(syn::TraitBound {
                paren_token: None,
                modifier: syn::TraitBoundModifier::None,
                lifetimes: None,
                path: bound.clone(),
            }));
        }

        if let Some(lifetime) = lifetime {
            bounds.push(syn::TypeParamBound::Lifetime(syn::Lifetime::new(
                lifetime,
                thing.span(),
            )));
        }

        syn::WherePredicate::Type(syn::PredicateType {
            lifetimes: None,
            bounded_ty: thing,
            colon_token: <Token![:]>::default(),
            bounds: bounds.into_iter().collect(),
        })
    }

    // place bounds on all used type parameters and associated types
    let mut new_predicates = visitor
        .used
        .into_iter()
        .cloned()
        .map(|bounded_ty| where_predicate(syn::Type::Path(bounded_ty), bound, lifetime))
        .collect::<Vec<_>>();

    // Add lifetime bounds to all type parameters, regardless of usage, due to how
    // lifetimes for generic types are determined.
    new_predicates.extend(generics.type_params().map(|param| {
        where_predicate(
            syn::Type::Path(syn::TypePath {
                qself: None,
                path: param.ident.clone().into(),
            }),
            None,
            lifetime,
        )
    }));

    let mut generics = generics;
    generics
        .make_where_clause()
        .predicates
        .extend(new_predicates);

    generics
}