alef 0.87.1

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
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

//! Lockstep guard: for a fully-flattened internally-tagged enum's `JsValue` field boundary, the
//! wasm backend's emitted RUNTIME conversion and its declared `.d.ts` SHAPE must move together.
//!
//! `ts_union::tests`'s `flattened_internal_enum_*` tests already pin the declaration half in
//! isolation, and `conversions::core_to_binding::fields::wasm_camel_recase_tests` /
//! `conversions::binding_to_core::fields::wasm_camel_recase_tests` already pin the conversion
//! string-building logic in isolation, against a hand-built `ConversionConfig`. Neither proves
//! that `backends::wasm::gen_bindings::mod`'s real `generate_bindings` run actually WIRES
//! `ConversionConfig::wasm_camel_recased_enums` from its own `JsonWireTypes` registration -- that
//! is exactly the asymmetry `codegen::untagged_enum_wire_cross_backend_tests` was written to
//! catch for a different enum shape, and this module follows the same placement/shape for this
//! one: one real `WasmBackend::generate_bindings` run, one test asserting BOTH the emitted `From`
//! impl and the emitted `.d.ts` custom section in a single body, so a change that moves only one
//! side fails here even though every narrower, hand-built-config unit test still passes.

use crate::core::backend::Backend;
use crate::core::config::ResolvedCrateConfig;
use crate::core::ir::{
    ApiSurface, EnumDef, EnumVariant, FieldDef, FunctionDef, ParamDef, PrimitiveType, TypeDef, TypeRef,
};

use crate::backends::wasm::WasmBackend;

/// `#[serde(tag = "format_type")] enum FormatMetadata { Excel(ExcelMetadata) }` -- the newtype
/// payload flattens into the tag object, so `is_fully_flattened_internal_enum` claims it and it
/// crosses the wasm `JsValue` boundary through the camel-recasing wire-type pipeline rather than
/// a plain `serde_wasm_bindgen` passthrough.
fn format_metadata_enum() -> EnumDef {
    EnumDef {
        name: "FormatMetadata".to_string(),
        rust_path: "test_lib::FormatMetadata".to_string(),
        serde_tag: Some("format_type".to_string()),
        has_serde: true,
        variants: vec![EnumVariant {
            name: "Excel".to_string(),
            is_tuple: true,
            fields: vec![FieldDef {
                name: "_0".to_string(),
                ty: TypeRef::Named("ExcelMetadata".to_string()),
                ..Default::default()
            }],
            ..Default::default()
        }],
        ..Default::default()
    }
}

fn excel_metadata_type() -> TypeDef {
    TypeDef {
        name: "ExcelMetadata".to_string(),
        rust_path: "test_lib::ExcelMetadata".to_string(),
        has_serde: true,
        fields: vec![FieldDef {
            name: "sheet_count".to_string(),
            ty: TypeRef::Primitive(PrimitiveType::U32),
            ..Default::default()
        }],
        ..Default::default()
    }
}

/// A struct holding the enum as a required field, mirroring a real `DocumentResult { format:
/// FormatMetadata, .. }`.
fn document_result_type() -> TypeDef {
    TypeDef {
        name: "DocumentResult".to_string(),
        rust_path: "test_lib::DocumentResult".to_string(),
        has_serde: true,
        fields: vec![FieldDef {
            name: "format".to_string(),
            ty: TypeRef::Named("FormatMetadata".to_string()),
            optional: false,
            ..Default::default()
        }],
        ..Default::default()
    }
}

/// A free function taking `DocumentResult` by value, so `input_type_names` treats it as an input
/// type and the binding->core `From` impl (the JS -> core half of the lockstep) is actually
/// emitted rather than skipped as dead code -- mirrors
/// `backends::wasm::gen_bindings::untagged_enum_tests::function_taking`.
fn function_taking_document_result() -> FunctionDef {
    FunctionDef {
        name: "use_document_result".to_string(),
        rust_path: "test_lib::use_document_result".to_string(),
        params: vec![ParamDef {
            name: "value".to_string(),
            ty: TypeRef::Named("DocumentResult".to_string()),
            ..Default::default()
        }],
        ..Default::default()
    }
}

fn fixture_api() -> ApiSurface {
    ApiSurface {
        crate_name: "test-lib".to_string(),
        version: "0.1.0".to_string(),
        enums: vec![format_metadata_enum()],
        types: vec![excel_metadata_type(), document_result_type()],
        functions: vec![function_taking_document_result()],
        ..ApiSurface::default()
    }
}

fn generated_wasm_source() -> String {
    WasmBackend
        .generate_bindings(&fixture_api(), &ResolvedCrateConfig::default())
        .expect("wasm backend must generate bindings for the fixture")
        .iter()
        .map(|f| f.content.as_str())
        .collect::<Vec<_>>()
        .join("\n")
}

/// The lockstep assertion itself. See the module doc comment for why this must be ONE test body
/// rather than two separate ones: a regression that reverts only the conversion, or only the
/// declaration, must fail THIS test either way.
#[test]
fn recased_enum_field_conversion_and_declaration_move_together() {
    let source = generated_wasm_source();
    assert!(
        !source.is_empty(),
        "PROBE: the wasm backend must emit something for the fixture"
    );

    // --- Runtime half: the emitted `From` impl for `DocumentResult` must route `format` through
    // the camel wire-type pipeline, not a bare `serde_wasm_bindgen::to_value`/`from_value` on the
    // raw core enum. `__alef_wire_retag_wasm` only appears when the pipeline is actually used --
    // see `codegen::conversions::core_to_binding::fields::camel_jsvalue` /
    // `codegen::conversions::binding_to_core::fields::camel_core_value`.
    assert!(
        source.contains("serde_wasm_bindgen::to_value(&__alef_wire_retag_wasm(serde_json::to_value(&val.format)"),
        "core->binding conversion for `format` must route through the retag+wire-type pipeline, \
         not a bare serde_wasm_bindgen::to_value on the raw core enum; actual source:\n{source}"
    );
    assert!(
        source.contains("serde_json::from_value::<__AlefWireInWasmFormatMetadata>("),
        "binding->core conversion for `format` must decode through the wire-type mirror; actual \
         source:\n{source}"
    );

    // --- Declaration half: the `.d.ts` custom section for this enum must declare camelCase keys.
    assert!(
        source.contains("formatType:"),
        "declared discriminant key must be camelCase; actual source:\n{source}"
    );
    assert!(
        source.contains("sheetCount:"),
        "declared payload field must be camelCase; actual source:\n{source}"
    );
    // Precise TS-declaration-shaped patterns, not a bare `sheet_count:`/`format_type:` substring:
    // the generated Rust source legitimately contains `sheet_count: u32,` (the wasm-bindgen
    // struct's own Rust field) and `"format_type"` (the retag helper's own string-literal
    // argument) for entirely correct, unrelated reasons -- a bare substring check would false-
    // positive on those and fail even when the declaration is genuinely all camelCase.
    assert!(
        !source.contains("sheet_count: number"),
        "must not declare the snake_case TS field type the runtime no longer produces; actual \
         source:\n{source}"
    );
    assert!(
        !source.contains("{ format_type: \""),
        "must not declare the snake_case TS discriminant literal the runtime no longer produces; \
         actual source:\n{source}"
    );
}