boltffi_bindgen 0.24.1

Code generation library for BoltFFI - generates Swift, Kotlin, and TypeScript bindings
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

use boltffi_ffi_rules::transport::EnumTagStrategy;

use crate::ir::ids::{BuiltinId, CustomTypeId, EnumId, FieldName, RecordId, VariantName};
use crate::ir::types::{PrimitiveType, TypeExpr};

/// Describes how a type is laid out on the wire: either blittable (fixed-size,
/// no pointers, can be read at known offsets) or variable-length encoded
/// (needs length prefixes and position tracking).
///
/// Recursive types like a tree node containing children of the same type
/// always get encoded layout because their size is not fixed.
#[derive(Debug, Clone)]
pub enum CodecPlan {
    Void,
    Primitive(PrimitiveType),
    String,
    Bytes,
    Builtin(BuiltinId),

    Option(Box<CodecPlan>),
    Vec {
        element: Box<CodecPlan>,
        layout: VecLayout,
    },
    Result {
        ok: Box<CodecPlan>,
        err: Box<CodecPlan>,
    },

    Record {
        id: RecordId,
        layout: RecordLayout,
    },
    Enum {
        id: EnumId,
        layout: EnumLayout,
    },
    Custom {
        id: CustomTypeId,
        underlying: Box<CodecPlan>,
    },
}

impl From<&CodecPlan> for TypeExpr {
    fn from(codec: &CodecPlan) -> Self {
        match codec {
            CodecPlan::Void => TypeExpr::Void,
            CodecPlan::Primitive(p) => TypeExpr::Primitive(*p),
            CodecPlan::String => TypeExpr::String,
            CodecPlan::Bytes => TypeExpr::Bytes,
            CodecPlan::Builtin(id) => TypeExpr::Builtin(id.clone()),
            CodecPlan::Option(inner) => TypeExpr::Option(Box::new(TypeExpr::from(inner.as_ref()))),
            CodecPlan::Vec { element, .. } => {
                TypeExpr::Vec(Box::new(TypeExpr::from(element.as_ref())))
            }
            CodecPlan::Result { ok, err } => TypeExpr::Result {
                ok: Box::new(TypeExpr::from(ok.as_ref())),
                err: Box::new(TypeExpr::from(err.as_ref())),
            },
            CodecPlan::Record { id, .. } => TypeExpr::Record(id.clone()),
            CodecPlan::Enum { id, .. } => TypeExpr::Enum(id.clone()),
            CodecPlan::Custom { id, .. } => TypeExpr::Custom(id.clone()),
        }
    }
}

#[derive(Debug, Clone)]
pub enum VecLayout {
    Blittable { element_size: usize },
    Encoded,
}

#[derive(Debug, Clone)]
pub enum RecordLayout {
    Blittable {
        size: usize,
        fields: Vec<BlittableField>,
    },
    Encoded {
        fields: Vec<EncodedField>,
    },
    Recursive,
}

impl RecordLayout {
    pub fn is_blittable(&self) -> bool {
        matches!(self, RecordLayout::Blittable { .. })
    }
}

#[derive(Debug, Clone)]
pub struct BlittableField {
    pub name: FieldName,
    pub offset: usize,
    pub primitive: PrimitiveType,
}

#[derive(Debug, Clone)]
pub struct EncodedField {
    pub name: FieldName,
    pub codec: CodecPlan,
}

#[derive(Debug, Clone)]
pub enum EnumLayout {
    CStyle {
        tag_type: PrimitiveType,
        tag_strategy: EnumTagStrategy,
        is_error: bool,
    },
    Data {
        tag_type: PrimitiveType,
        tag_strategy: EnumTagStrategy,
        variants: Vec<VariantLayout>,
    },
    Recursive,
}

#[derive(Debug, Clone)]
pub struct VariantLayout {
    pub name: VariantName,
    pub discriminant: i128,
    pub payload: VariantPayloadLayout,
}

#[derive(Debug, Clone)]
pub enum VariantPayloadLayout {
    Unit,
    Fields(Vec<EncodedField>),
}