uniffi_bindgen 0.32.0

a multi-language bindings generator for rust (codegen and cli tooling)
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use super::*;

pub fn ffi_definitions(namespace: &initial::Namespace) -> Result<Vec<FfiDefinition>> {
    if !has_async_fns(namespace) {
        return Ok(vec![]);
    }

    let crate_name = namespace.crate_name.clone();
    let mut ffi_defs = vec![];

    ffi_defs.extend([FfiFunctionType {
        name: FfiFunctionTypeName("RustFutureContinuationCallback".to_owned()),
        arguments: vec![
            FfiArgument::new("data", FfiType::Handle(HandleKind::RustFuture)),
            FfiArgument::new("poll_result", FfiType::Int8),
        ],
        return_type: FfiReturnType { ty: None },
        has_rust_call_status_arg: false,
    }
    .into()]);

    let all_async_return_types = [
        (Some(FfiType::UInt8), "u8"),
        (Some(FfiType::Int8), "i8"),
        (Some(FfiType::UInt16), "u16"),
        (Some(FfiType::Int16), "i16"),
        (Some(FfiType::UInt32), "u32"),
        (Some(FfiType::Int32), "i32"),
        (Some(FfiType::UInt64), "u64"),
        (Some(FfiType::Int64), "i64"),
        (Some(FfiType::Float32), "f32"),
        (Some(FfiType::Float64), "f64"),
        (
            Some(FfiType::Handle(HandleKind::StructInterface {
                namespace: "".into(),
                interface_name: "".into(),
            })),
            "u64",
        ),
        (
            Some(FfiType::Handle(HandleKind::TraitInterface {
                namespace: "".into(),
                interface_name: "".into(),
            })),
            "u64",
        ),
        (Some(FfiType::RustBuffer(None)), "rust_buffer"),
        (None, "void"),
    ];
    for (return_type, return_type_name) in all_async_return_types {
        let poll_name = format!("ffi_{crate_name}_rust_future_poll_{return_type_name}");
        ffi_defs.push(ffi_rust_future_poll(poll_name));

        let cancel_name = format!("ffi_{crate_name}_rust_future_cancel_{return_type_name}");
        ffi_defs.push(ffi_rust_future_cancel(cancel_name));

        let complete_name = format!("ffi_{crate_name}_rust_future_complete_{return_type_name}");
        ffi_defs.push(ffi_rust_future_complete(return_type.clone(), complete_name));

        let free_name = format!("ffi_{crate_name}_rust_future_free_{return_type_name}");
        ffi_defs.push(ffi_rust_future_free(free_name));
    }
    Ok(ffi_defs)
}

fn ffi_rust_future_poll(symbol_name: String) -> FfiDefinition {
    FfiFunction {
        name: RustFfiFunctionName(symbol_name),
        async_data: None,
        arguments: vec![
            FfiArgument {
                name: "handle".to_owned(),
                ty: FfiType::Handle(HandleKind::RustFuture),
            },
            FfiArgument {
                name: "callback".to_owned(),
                ty: FfiType::Function(FfiFunctionTypeName(
                    "RustFutureContinuationCallback".to_owned(),
                )),
            },
            FfiArgument {
                name: "callback_data".to_owned(),
                ty: FfiType::Handle(HandleKind::RustFuture),
            },
        ],
        return_type: FfiReturnType { ty: None },
        has_rust_call_status_arg: false,
        kind: FfiFunctionKind::RustFuturePoll,
    }
    .into()
}

fn ffi_rust_future_cancel(symbol_name: String) -> FfiDefinition {
    FfiFunction {
        name: RustFfiFunctionName(symbol_name),
        async_data: None,
        arguments: vec![FfiArgument {
            name: "handle".to_owned(),
            ty: FfiType::Handle(HandleKind::RustFuture),
        }],
        return_type: FfiReturnType { ty: None },
        has_rust_call_status_arg: false,
        kind: FfiFunctionKind::RustFutureCancel,
    }
    .into()
}

fn ffi_rust_future_complete(return_type: Option<FfiType>, symbol_name: String) -> FfiDefinition {
    FfiFunction {
        name: RustFfiFunctionName(symbol_name),
        async_data: None,
        arguments: vec![FfiArgument {
            name: "handle".to_owned(),
            ty: FfiType::Handle(HandleKind::RustFuture),
        }],
        return_type: FfiReturnType { ty: return_type },
        has_rust_call_status_arg: true,
        kind: FfiFunctionKind::RustFutureComplete,
    }
    .into()
}

fn ffi_rust_future_free(symbol_name: String) -> FfiDefinition {
    FfiFunction {
        name: RustFfiFunctionName(symbol_name),
        async_data: None,
        arguments: vec![FfiArgument {
            name: "handle".to_owned(),
            ty: FfiType::Handle(HandleKind::RustFuture),
        }],
        return_type: FfiReturnType { ty: None },
        has_rust_call_status_arg: false,
        kind: FfiFunctionKind::RustFutureFree,
    }
    .into()
}

fn has_async_fns(namespace: &initial::Namespace) -> bool {
    namespace.has_descendant(|func: &initial::Function| func.is_async)
        || namespace.has_descendant(|meth: &initial::Method| meth.is_async)
        || namespace.has_descendant(|cons: &initial::Constructor| cons.is_async)
}