thru-abi-gen 0.2.30

ABI code generation utilities for the Thru blockchain
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

use super::helpers::{escape_ts_keyword, struct_field_const_offset};
use super::ir_helpers::sanitize_param_name;
use crate::abi::expr::ExprKind;
use crate::abi::resolved::{ResolvedEnumVariant, ResolvedField, ResolvedType, ResolvedTypeKind};

#[derive(Clone)]
pub struct EnumFieldInfo<'a> {
    pub enum_field: &'a ResolvedField,
    pub tag_field: Option<&'a ResolvedField>,
    pub variants: &'a [ResolvedEnumVariant],
    pub enum_ts_name: String,
    pub tag_ts_name: String,
    pub descriptor_prop: String,
    pub payload_offset: Option<u64>,
    pub tag_offset: Option<u64>,
    pub is_tail: bool,
    pub tag_expression: Option<ExprKind>,
    pub tag_parameter: Option<String>,
    pub tag_param_ts_name: Option<String>,
}

pub fn enum_field_info<'a>(resolved_type: &'a ResolvedType) -> Option<EnumFieldInfo<'a>> {
    let fields = match &resolved_type.kind {
        ResolvedTypeKind::Struct { fields, .. } => fields,
        _ => return None,
    };
    let enum_field = fields
        .iter()
        .find(|field| matches!(field.field_type.kind, ResolvedTypeKind::Enum { .. }))?;
    build_enum_field_info(resolved_type, fields, enum_field)
}

pub fn enum_field_info_by_name<'a>(
    resolved_type: &'a ResolvedType,
    field_name: &str,
) -> Option<EnumFieldInfo<'a>> {
    let fields = match &resolved_type.kind {
        ResolvedTypeKind::Struct { fields, .. } => fields,
        _ => return None,
    };
    let enum_field = fields.iter().find(|field| {
        field.name == field_name && matches!(field.field_type.kind, ResolvedTypeKind::Enum { .. })
    })?;
    build_enum_field_info(resolved_type, fields, enum_field)
}

pub fn enum_field_infos<'a>(resolved_type: &'a ResolvedType) -> Vec<EnumFieldInfo<'a>> {
    let fields = match &resolved_type.kind {
        ResolvedTypeKind::Struct { fields, .. } => fields,
        _ => return Vec::new(),
    };
    fields
        .iter()
        .filter_map(|field| {
            if matches!(field.field_type.kind, ResolvedTypeKind::Enum { .. }) {
                build_enum_field_info(resolved_type, fields, field)
            } else {
                None
            }
        })
        .collect()
}

fn build_enum_field_info<'a>(
    struct_type: &'a ResolvedType,
    fields: &'a [ResolvedField],
    enum_field: &'a ResolvedField,
) -> Option<EnumFieldInfo<'a>> {
    let (variants, tag_data) = match &enum_field.field_type.kind {
        ResolvedTypeKind::Enum {
            variants,
            tag_expression,
            ..
        } => {
            if let Some(tag_name) = extract_field_name(tag_expression) {
                (variants, EnumTagSource::Field(tag_name.to_string()))
            } else {
                (variants, EnumTagSource::Computed(tag_expression.clone()))
            }
        }
        _ => return None,
    };

    let (tag_field_opt, tag_ts_name, tag_offset, tag_expression, tag_parameter) = match tag_data {
        EnumTagSource::Field(name) => {
            let tag_field = fields.iter().find(|field| field.name == name)?;
            let offset = tag_field
                .offset
                .or_else(|| struct_field_const_offset(struct_type, &tag_field.name));
            (
                Some(tag_field),
                escape_ts_keyword(&tag_field.name),
                offset,
                None,
                None,
            )
        }
        EnumTagSource::Computed(expr) => (
            None,
            escape_ts_keyword(&format!("{}_computed_tag", enum_field.name)),
            None,
            Some(expr.clone()),
            Some(format!("{}.computed_tag", enum_field.field_type.name)),
        ),
    };

    let payload_offset = enum_field
        .offset
        .or_else(|| struct_field_const_offset(struct_type, &enum_field.name));
    let is_tail = fields
        .iter()
        .enumerate()
        .find(|(_, field)| std::ptr::eq(*field, enum_field))
        .map(|(idx, _)| idx + 1 == fields.len())
        .unwrap_or(false);
    let tag_param_ts_name = tag_parameter.as_ref().map(|name| sanitize_param_name(name));

    Some(EnumFieldInfo {
        enum_field,
        tag_field: tag_field_opt,
        variants,
        enum_ts_name: escape_ts_keyword(&enum_field.name),
        tag_ts_name,
        descriptor_prop: format!("{}VariantDescriptors", escape_ts_keyword(&enum_field.name)),
        payload_offset,
        tag_offset,
        is_tail,
        tag_expression,
        tag_parameter,
        tag_param_ts_name,
    })
}

enum EnumTagSource {
    Field(String),
    Computed(ExprKind),
}

fn extract_field_name(expr: &ExprKind) -> Option<&str> {
    match expr {
        ExprKind::FieldRef(field_ref) if field_ref.path.len() == 1 => {
            field_ref.path.first().map(|s| s.as_str())
        }
        _ => None,
    }
}