nougat-proc_macros 0.2.4

Internal: proc-macro backend of ::nougat.
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

//! Try to `#[apply(Gat!)]` to each and every type path.
//!
//! The name is a pun since this kind of "transposes" the given type paths.

use super::*;

pub(in super)
fn adjugate (
    _attrs: parse::Nothing,
    mut input: Item,
) -> Item
{
    visit_mut::VisitMut::visit_item_mut(
        &mut ApplyGatToEachTypePathOccurrence,
        &mut input,
    );
    input
}

struct ApplyGatToEachTypePathOccurrence;

impl visit_mut::VisitMut for ApplyGatToEachTypePathOccurrence {
    fn visit_type_mut (
        self: &'_ mut ApplyGatToEachTypePathOccurrence,
        type_: &'_ mut Type,
    )
    {
        visit_mut::visit_type_mut(self, type_); // subrecurse
        match *type_ {
            | Type::Path(ref type_path) => {
                match Gat::Gat(Gat::Input::TypePath(type_path.clone())) {
                    | Ok(modified_type_path) => {
                        // Trick: using `Verbatim` over `parse2` skips a layer
                        // of unnecessary parsing.
                        *type_ = Type::Verbatim(modified_type_path);
                    },
                    | Err(()) => {},
                }
            },
            | Type::ImplTrait(ref impl_trait) => {
                match Gat::Gat(Gat::Input::TypeImpl(impl_trait.clone())) {
                    | Ok(modified_type_path) => {
                        // Trick: using `Verbatim` over `parse2` skips a layer
                        // of unnecessary parsing.
                        *type_ = Type::Verbatim(modified_type_path);
                    },
                    | Err(()) => {},
                }
            },
            | _ => {},
        }
    }

    fn visit_type_param_mut (
        self: &'_ mut ApplyGatToEachTypePathOccurrence,
        type_param: &'_ mut TypeParam,
    )
    {
        visit_mut::visit_type_param_mut(self, type_param); // subrecurse
        crate::Gat::handle_trait_bounds(&mut type_param.bounds);
    }

    fn visit_predicate_type_mut (
        self: &'_ mut ApplyGatToEachTypePathOccurrence,
        predicate_type: &'_ mut PredicateType,
    )
    {
        visit_mut::visit_predicate_type_mut(self, predicate_type); // subrecurse
        crate::Gat::handle_trait_bounds(&mut predicate_type.bounds);
    }

    fn visit_item_trait_mut (
        self: &'_ mut ApplyGatToEachTypePathOccurrence,
        item_trait: &'_ mut ItemTrait,
    )
    {
        visit_mut::visit_item_trait_mut(self, item_trait); // subrecurse
        crate::Gat::handle_trait_bounds(&mut item_trait.supertraits);
    }
}