telety-impl 0.4.0

Common code for telety. Not intended for public use.
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

use std::collections::HashSet;

use crate::alias;

pub struct IdentifyAliases<'m, 'map> {
    alias_map: &'m mut alias::Map<'map>,
    parameters: HashSet<syn::Ident>,
}

impl<'m, 'map> IdentifyAliases<'m, 'map> {
    pub fn new(alias_map: &'m mut alias::Map<'map>) -> Self {
        let parameters = alias_map
            .generics()
            .params
            .iter()
            .filter_map(|p| match p {
                syn::GenericParam::Lifetime(_lifetime_param) => None,
                syn::GenericParam::Type(type_param) => Some(&type_param.ident),
                syn::GenericParam::Const(const_param) => Some(&const_param.ident),
            })
            .cloned()
            .collect();

        Self {
            alias_map,
            parameters,
        }
    }

    fn is_parameter(&self, ident: &syn::Ident) -> bool {
        self.parameters.contains(ident)
    }
}

impl<'m, 'map> directed_visit::syn::visit::Full for IdentifyAliases<'m, 'map> {
    fn visit_generics_enter<D>(
        mut visitor: directed_visit::Visitor<'_, D, Self>,
        node: &directed_visit::syn::GenericsEnter,
    ) where
        D: directed_visit::Direct<Self, directed_visit::syn::GenericsEnter> + ?Sized,
    {
        for param in node {
            if let syn::GenericParam::Type(param) = param {
                visitor.parameters.insert(param.ident.clone());
            }
        }
    }

    fn visit_generics_exit<D>(
        mut visitor: directed_visit::Visitor<'_, D, Self>,
        node: &directed_visit::syn::GenericsExit,
    ) where
        D: directed_visit::Direct<Self, directed_visit::syn::GenericsExit> + ?Sized,
    {
        for param in node {
            if let syn::GenericParam::Type(param) = param {
                visitor.parameters.remove(&param.ident);
            }
        }
    }

    fn visit_type_path<D>(mut visitor: directed_visit::Visitor<'_, D, Self>, node: &syn::TypePath)
    where
        D: directed_visit::Direct<Self, syn::TypePath> + ?Sized,
    {
        if let Some(first_segment) = node.path.segments.first()
            && node.path.leading_colon.is_none()
            && (first_segment.ident == "Self" || visitor.is_parameter(&first_segment.ident))
        {
            // TypePath is a type parameter or associated type of one
            return;
        }

        // No error handling, we just alias everything we are able to
        let _ = visitor.alias_map.insert_type(node);

        directed_visit::Visitor::visit(visitor, node);
    }

    fn visit_trait_bound<D>(
        mut visitor: directed_visit::Visitor<'_, D, Self>,
        node: &syn::TraitBound,
    ) where
        D: directed_visit::Direct<Self, syn::TraitBound> + ?Sized,
    {
        // No error handling, we just alias everything we are able to
        let _ = visitor.alias_map.insert_trait(&node.path);
        directed_visit::Visitor::visit(visitor, node);
    }
}