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

use syn::punctuated::Punctuated;
use syn::visit::Visit;
use syn::{GenericParam, Generics};

use crate::utils::extend_bounds::{with_visitor, BoundsVisitor};
use crate::variant::repr::StructRepr;

use super::repr::{EnumRepr, Field, Repr, VariantRepr};
use super::Direction;

pub(crate) fn extend_bounds(
    generics: Generics,
    repr: &Repr,
    bound: &syn::Path,
    dir: Direction,
) -> Generics {
    with_visitor(generics, Some(bound), None, |visitor| {
        // iterate through parsed variant representations and visit the types of each field
        fn visit_var_repr<'ast>(
            visitor: &mut BoundsVisitor<'ast>,
            repr: &'ast VariantRepr,
            dir: Direction,
        ) {
            match repr {
                VariantRepr::Unit(_) => {}
                VariantRepr::Tuple(tys) => {
                    for Field { ty, attr, .. } in tys.iter() {
                        if !attr.skip_bounds(dir) {
                            visitor.visit_type(ty);
                        }
                    }
                }
                VariantRepr::Struct(fields) => {
                    for Field { ty, attr, .. } in fields.iter() {
                        if !attr.skip_bounds(dir) {
                            visitor.visit_type(ty);
                        }
                    }
                }
            }
        }

        match repr {
            Repr::Enum(EnumRepr { ref variants, .. }) => {
                for (_, var_repr) in variants.iter() {
                    visit_var_repr(visitor, var_repr, dir);
                }
            }
            Repr::Struct(StructRepr(var_repr)) => {
                visit_var_repr(visitor, var_repr, dir);
            }
        }
    })
}

pub(crate) fn remove_bounds(mut generics: Generics) -> Generics {
    for param in generics.params.iter_mut() {
        match param {
            GenericParam::Type(ty) => {
                ty.colon_token = None;
                ty.bounds = Punctuated::new();
            }
            GenericParam::Lifetime(lt) => {
                lt.colon_token = None;
                lt.bounds = Punctuated::new();
            }
            GenericParam::Const(_) => {}
        }
    }
    generics
}