ferment-sys 0.2.14

Syntax tree morphing of FFI-compatible stuff
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

use std::fmt::{Debug, Display, Formatter};
use quote::ToTokens;
use syn::{Attribute, Item, ItemEnum, ItemStruct, ItemTrait, ItemType, Path, Signature, Type};
use syn::__private::TokenStream2;
use crate::composable::{CfgAttributes, TraitDecompositionPart1, TraitModel, TypeModel};
use crate::kind::{TypeModelKind};
use crate::ext::{collect_bounds, MaybeIdent, MaybeAttrs, ResolveAttrs};
use crate::formatter::format_token_stream;

#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScopeItemKind {
    Item(Item, Path),
    Fn(Signature, Path),
}

impl ToTokens for ScopeItemKind {
    fn to_tokens(&self, tokens: &mut TokenStream2) {
        match self {
            ScopeItemKind::Item(item, ..) => item.to_tokens(tokens),
            ScopeItemKind::Fn(sig, ..) => sig.to_tokens(tokens)
        }
    }
}
impl Debug for ScopeItemKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ScopeItemKind::Item(item, scope) =>
                f.write_fmt(format_args!("Item({}, {})", format_token_stream(item.maybe_ident()), scope.to_token_stream())),
            ScopeItemKind::Fn(Signature { ident, .. }, scope) =>
                f.write_fmt(format_args!("Fn({}, {})", format_token_stream(ident), scope.to_token_stream())),
        }
    }
}

impl Display for ScopeItemKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(self, f)
    }
}

impl ResolveAttrs for ScopeItemKind {
    fn resolve_attrs(&self) -> Vec<Option<Attribute>> {
        self.maybe_attrs()
            .map(CfgAttributes::cfg_attributes_or_none)
            .unwrap_or_default()
    }
}

impl ScopeItemKind {
    pub fn item(item: Item, scope: Path) -> Self {
        Self::Item(item, scope)
    }
    pub fn r#fn(sig: Signature, scope: Path) -> Self {
        Self::Fn(sig, scope)
    }
    pub fn item_ref(item: &Item, scope: &Path) -> Self {
        Self::item(item.clone(), scope.clone())
    }
    pub fn fn_ref(sig: &Signature, scope: &Path) -> Self {
        Self::Fn(sig.clone(), scope.clone())
    }

    pub fn item_enum(item_enum: &ItemEnum, scope: &Path) -> Self {
        Self::item(Item::Enum(item_enum.clone()), scope.clone())
    }
    pub fn item_struct(item_struct: &ItemStruct, scope: &Path) -> Self {
        Self::item(Item::Struct(item_struct.clone()), scope.clone())
    }
    pub fn item_type(item_type: &ItemType, scope: &Path) -> Self {
        Self::item(Item::Type(item_type.clone()), scope.clone())
    }
    pub fn item_trait(item_trait: &ItemTrait, scope: &Path) -> Self {
        Self::item(Item::Trait(item_trait.clone()), scope.clone())
    }
}
impl ScopeItemKind {
    pub fn update_with(&self, ty_to_replace: TypeModel) -> Option<TypeModelKind> {
        match self {
            ScopeItemKind::Item(item, ..) => match item {
                Item::Trait(ItemTrait { ident, items, supertraits, .. }) =>
                    Some(TypeModelKind::Trait(TraitModel::new(ty_to_replace, TraitDecompositionPart1::from_trait_items(ident, items), collect_bounds(supertraits)))),
                Item::Enum(..) |
                Item::Struct(..) |
                Item::Fn(..) |
                Item::Impl(..) =>
                    Some(TypeModelKind::Object(ty_to_replace)),
                Item::Type(ty) => Some(match &*ty.ty {
                    Type::BareFn(..) =>
                        TypeModelKind::FnPointer,
                    _ =>
                        TypeModelKind::Object,
                }(ty_to_replace)),
                _ => None
            }
            ScopeItemKind::Fn(..) => None
        }
    }
    pub fn scope(&self) -> &Path {
        match self {
            ScopeItemKind::Item(.., scope) |
            ScopeItemKind::Fn(.., scope) => scope
        }
    }
    pub fn path(&self) -> &Path {
        self.scope()
    }
}