flutter_rust_bridge_codegen 2.14.0-beta.1

Flutter/Dart <-> Rust binding generator, feature-rich, but seamless and simple
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

use crate::codegen::ir::hir::misc::item_fn::GeneralizedItemFn;
use crate::utils::syn_utils::ty_to_string;
use itertools::Itertools;
use quote::ToTokens;
use serde::{Serialize, Serializer};

pub(crate) fn serialize_syn<T: ToTokens, S: Serializer>(
    value: &T,
    s: S,
) -> Result<S::Ok, S::Error> {
    quote::quote!(#value).to_string().serialize(s)
}

pub(crate) fn serialize_vec_syn<T: ToTokens, S: Serializer>(
    values: &[T],
    s: S,
) -> Result<S::Ok, S::Error> {
    let values = values
        .iter()
        .map(|value| quote::quote!(#value).to_string())
        .collect_vec();
    values.serialize(s)
}

// pub(crate) fn serialize_item_trait<S: Serializer>(x: &ItemTrait, s: S) -> Result<S::Ok, S::Error> {
//     s.serialize_str(&format!("ItemTrait(ident={})", x.ident))
// }
//
// pub(crate) fn serialize_item_impl<S: Serializer>(x: &ItemImpl, s: S) -> Result<S::Ok, S::Error> {
//     s.serialize_str(&format!(
//         "ItemImpl(self_ty={}, trait={})",
//         ty_to_string(&x.self_ty),
//         x.trait_
//             .as_ref()
//             .map(|t| ty_to_string(&t.1).replace(' ', ""))
//             .unwrap_or("None".to_owned())
//     ))
// }

pub(crate) fn serialize_generalized_item_fn<S: Serializer>(
    x: &GeneralizedItemFn,
    s: S,
) -> Result<S::Ok, S::Error> {
    s.serialize_str(&format!(
        "GeneralizedItemFn(name={}, vis={:?}, attrs=[{}])",
        x.name(),
        x.vis_raw(),
        x.attrs().iter().map(ty_to_string).join(", "),
    ))
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Checks Syn value/vector encoding and function metadata fields.
    #[test]
    fn serializes_syn_values_and_function_metadata() {
        let item: syn::ItemStruct = syn::parse_str("pub struct Example<T>(T);").unwrap();
        assert_eq!(
            serde_json::to_string(&SynValue(&item)).unwrap(),
            "\"pub struct Example < T > (T) ;\""
        );

        let values = vec![
            syn::parse_str::<syn::Type>("u8").unwrap(),
            syn::parse_str::<syn::Type>("String").unwrap(),
        ];
        assert_eq!(
            serde_json::to_string(&SynValues(&values)).unwrap(),
            "[\"u8\",\"String\"]"
        );

        let function = GeneralizedItemFn::ItemFn(
            syn::parse_str("#[inline] pub fn example(value: u8) {}").unwrap(),
        );
        let serialized = serde_json::to_string(&SerializableFunction(&function)).unwrap();
        assert!(serialized.contains("GeneralizedItemFn(name=example"));
        assert!(serialized.contains("attrs=["));
        assert!(serialized.contains("inline"));
    }

    struct SynValue<'a>(&'a syn::ItemStruct);

    impl serde::Serialize for SynValue<'_> {
        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
            serialize_syn(self.0, serializer)
        }
    }

    struct SynValues<'a>(&'a [syn::Type]);

    impl serde::Serialize for SynValues<'_> {
        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
            serialize_vec_syn(self.0, serializer)
        }
    }

    struct SerializableFunction<'a>(&'a GeneralizedItemFn);

    impl serde::Serialize for SerializableFunction<'_> {
        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
            serialize_generalized_item_fn(self.0, serializer)
        }
    }
}