dustr 0.1.2

Generate dart code based on a rust ffishim
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 ::once_cell::sync::Lazy;
use ::std::collections::HashMap;
use ::syn::*;
use crate::helpers::*;

/// Builtin scalar behaviors: `f32`, `u32`, ...
///
/// The behavior for different scalars is shared into this object. Handled here are:
///
///  - `char`
///  - `f32`
///  - `f64`
///  - `u8`
///  - `u16`
///  - `u32`
///  - `u64`
///  - `usize`
///  - `i8`
///  - `i16`
///  - `i32`
///  - `i64`
///  - `isize`
pub struct Behavior;

static NATIVE_TYPES: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
    let mut m = HashMap::new();
    m.insert("char", "int");
    m.insert("f32", "double");
    m.insert("f64", "double");
    m.insert("u8", "int");
    m.insert("u16", "int");
    m.insert("u32", "int");
    m.insert("u64", "int");
    //m.insert("usize", "int"); TODO un-handled usize/isize scalar types
    m.insert("i8", "int");
    m.insert("i16", "int");
    m.insert("i32", "int");
    m.insert("i64", "int");
    //m.insert("isize", "int"); TODO un-handled usize/isize scalar types
    m
});

#[allow(dead_code)]
static SHIM_TYPES: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
    let mut m = HashMap::new();
    m.insert("char", "Uint32");
    m.insert("f32", "Float");
    m.insert("f64", "Double");
    m.insert("u8", "Uint8");
    m.insert("u16", "Uint16");
    m.insert("u32", "Uint32");
    m.insert("u64", "Uint64");
    //m.insert("usize", "int"); TODO un-handled usize/isize scalar types
    m.insert("i8", "Int8");
    m.insert("i16", "Int16");
    m.insert("i32", "Int32");
    m.insert("i64", "Int64");
    //m.insert("isize", "int"); TODO un-handled usize/isize scalar types
    m
});

impl super::Behavior for Behavior {
    fn is(&self, sty: &Type) -> bool {
        if let Type::Path(tp) = sty {
            NATIVE_TYPES.keys().any(|t| {
                parse_str::<Path>(t).unwrap() == tp.path
            })
        } else {
            false
        }
    }
    fn imports(&self, _sty: &Type, _pkg: &str, _crate_name: &str) -> Vec<String> {
        vec!["dart:ffi".to_owned()]
    }
    fn name(&self, sty: &Type) -> String { type_name_from_path(sty) }

    fn shim(&self, sty: &Type) -> String {
        if let Type::Path(tp) = sty {
            let name = tp.path.get_ident().expect(".shim() with non-scalar type").to_string();
            SHIM_TYPES.get(name.as_str()).expect(".shim() with non-scalar type").to_string()
        } else {
            panic!("cannot call scalar .ffi() with non-scalar type");
        }
    }

    fn ffi(&self, sty: &Type) -> String {
        self.native(sty)
    }

    fn native(&self, sty: &Type) -> String {
        if let Type::Path(tp) = sty {
            let name = tp.path.get_ident().expect(".native() with non-scalar type").to_string();
            NATIVE_TYPES.get(name.as_str()).expect(".native() with non-scalar type").to_string()
        } else {
            panic!("cannot call scalar .native() with non-scalar type");
        }
    }

    fn native_to_ffi(&self, _sty: &Type, expr: String) -> String {
        expr
    }

    fn ffi_to_native(&self, _sty: &Type, expr: String) -> String {
        expr
    }

}