Skip to main content

bitwarden_ffi_macro/
wire.rs

1//! How the macros name a type's wire form in a generated signature.
2
3use proc_macro2::TokenStream;
4use quote::quote;
5use syn::Type;
6
7/// The type JavaScript passes for a parameter of type `ty`.
8///
9/// `#[wasm_record]` and `#[wasm_object]` implement `FromWasm` at each type's declaration site, so
10/// this resolves to `Ts<T>` for a serde DTO and to `T` for a `#[wasm_bindgen]` handle. A type that
11/// has declared neither is a missing-impl error naming the site.
12pub(crate) fn from_wire_type(ty: &Type) -> TokenStream {
13    quote!(<#ty as ::bitwarden_ffi::FromWasm>::Wire)
14}
15
16/// The type JavaScript receives for a value of type `ty`.
17pub(crate) fn to_wire_type(ty: &Type) -> TokenStream {
18    quote!(<#ty as ::bitwarden_ffi::ToWasm>::Wire)
19}
20
21/// Whether a value crosses the ABI as written, with no wire conversion.
22///
23/// References only: `Ts<T>` is passed by value, so a reference can never be wrapped. Covers `&[u8]`
24/// and borrowed handles such as `&JsCommunicationBackend`.
25pub(crate) fn crosses_bare(ty: &Type) -> bool {
26    matches!(ty, Type::Reference(_))
27}
28
29/// Whether a `catch` import's `Ok` type is `()` or `JsValue`, which need no wrapper to convert.
30pub(crate) fn returns_bare(ty: &Type) -> bool {
31    match ty {
32        Type::Tuple(tuple) => tuple.elems.is_empty(),
33        Type::Path(path) => {
34            path.qself.is_none()
35                && path
36                    .path
37                    .segments
38                    .last()
39                    .is_some_and(|segment| segment.ident == "JsValue")
40        }
41        _ => false,
42    }
43}
44
45/// `Result<R, E>` -> `(R, E)`.
46pub(crate) fn split_result(ty: &Type) -> Option<(&Type, &Type)> {
47    let Type::Path(path) = ty else { return None };
48    let segment = path.path.segments.last()?;
49    if segment.ident != "Result" {
50        return None;
51    }
52    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
53        return None;
54    };
55    let mut types = args.args.iter().filter_map(|arg| match arg {
56        syn::GenericArgument::Type(ty) => Some(ty),
57        _ => None,
58    });
59    Some((types.next()?, types.next()?))
60}