alef 0.114.0

Opinionated polyglot binding generator for Rust libraries
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

use crate::backends::csharp::type_map::csharp_type;
use crate::codegen::naming::{csharp_variant_name, to_csharp_name};
use crate::core::ir::{EnumDef, EnumVariant, FieldDef};

pub(crate) fn variant_field_type(enum_def: &EnumDef, field: &FieldDef) -> String {
    let ty = if field.sanitized && field.type_rust_path.is_some() {
        "object".to_string()
    } else {
        csharp_type(&field.ty).to_string()
    };
    let ty = if field.optional && !ty.ends_with('?') {
        format!("{ty}?")
    } else {
        ty
    };
    if enum_def
        .variants
        .iter()
        .any(|variant| ty.starts_with(&format!("{}<", csharp_variant_name(&variant.name))))
    {
        ty.replace("List<", "global::System.Collections.Generic.List<")
            .replace("Dictionary<", "global::System.Collections.Generic.Dictionary<")
    } else {
        ty
    }
}

pub(crate) fn variant_field_name(enum_def: &EnumDef, variant: &EnumVariant, field: &FieldDef) -> String {
    let public = to_csharp_name(field.name.trim_start_matches('_'));
    let clashes = public == csharp_variant_name(&variant.name)
        || public == variant_field_type(enum_def, field)
        || enum_def
            .variants
            .iter()
            .any(|other| csharp_variant_name(&other.name) == public);
    if super::super::is_tuple_field(field) || clashes {
        "Value".to_string()
    } else {
        public
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::ir::TypeRef;

    #[test]
    fn collision_policy_matches_released_properties_without_using_wire_names() {
        let mut enum_def = EnumDef {
            variants: vec![
                EnumVariant {
                    name: "Text".into(),
                    ..Default::default()
                },
                EnumVariant {
                    name: "Other".into(),
                    ..Default::default()
                },
            ],
            ..Default::default()
        };
        for (name, ty, expected) in [
            ("text", TypeRef::String, "Value"),
            ("other", TypeRef::String, "Value"),
            ("details", TypeRef::Named("Details".into()), "Value"),
            ("caption", TypeRef::String, "Caption"),
            ("_0", TypeRef::String, "Value"),
        ] {
            let field = FieldDef {
                name: name.into(),
                ty,
                serde_rename: Some("wire_only".into()),
                ..Default::default()
            };
            enum_def.variants[0].fields = vec![field.clone()];
            assert_eq!(variant_field_name(&enum_def, &enum_def.variants[0], &field), expected);
        }
    }
}