alef 0.26.6

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

//! Tests for the Rustler-local same-name function re-gating pass.

use super::regate_ungated_same_name_functions;
use crate::core::ir::{FunctionDef, ParamDef, TypeRef};

fn make_param(name: &str) -> ParamDef {
    ParamDef {
        name: name.to_string(),
        ty: TypeRef::String,
        ..Default::default()
    }
}

fn make_fn(name: &str, rust_path: &str, cfg: Option<&str>, param_names: &[&str]) -> FunctionDef {
    FunctionDef {
        name: name.to_string(),
        rust_path: rust_path.to_string(),
        original_rust_path: String::new(),
        params: param_names.iter().map(|n| make_param(n)).collect(),
        return_type: TypeRef::String,
        is_async: false,
        error_type: None,
        doc: String::new(),
        cfg: cfg.map(|s| s.to_string()),
        sanitized: false,
        return_sanitized: false,
        returns_ref: false,
        returns_cow: false,
        return_newtype_wrapper: None,
        binding_excluded: false,
        binding_exclusion_reason: None,
        version: Default::default(),
    }
}

fn normalize_cfg(s: &str) -> String {
    s.chars().filter(|c| !c.is_whitespace()).collect()
}

/// The canonical fallback shape: two disjoint gated arms plus an ungated stub fallback.
/// The two gated arms must survive untouched, and the ungated stub must be re-gated to
/// `not(any(<both gated cfgs>))` so it never compiles alongside an active arm.
#[test]
fn regates_ungated_fallback_against_gated_arms() {
    let input = vec![
        make_fn(
            "known_models",
            "krate::text::ner::known_models",
            Some(r#"feature = "ner-onnx""#),
            &[],
        ),
        make_fn(
            "known_models",
            "krate::text::ner::known_models",
            Some(r#"not(feature = "ner-onnx")"#),
            &[],
        ),
        make_fn("known_models", "krate::text::ner::known_models", None, &[]),
    ];

    let out = regate_ungated_same_name_functions(&input);

    assert_eq!(
        out.len(),
        3,
        "all three arms must survive — only the ungated one is re-gated"
    );
    assert_eq!(
        out[0].cfg.as_deref(),
        Some(r#"feature = "ner-onnx""#),
        "first gated arm must be untouched"
    );
    assert_eq!(
        out[1].cfg.as_deref(),
        Some(r#"not(feature = "ner-onnx")"#),
        "second gated arm must be untouched"
    );

    let fallback_cfg = out[2].cfg.as_deref().expect("the ungated fallback must now be gated");
    let norm = normalize_cfg(fallback_cfg);
    assert!(
        norm.starts_with("not(any("),
        "fallback must be gated as not(any(...)); got: {fallback_cfg}"
    );
    assert!(
        norm.contains(&normalize_cfg(r#"feature = "ner-onnx""#)),
        "fallback gate must reference the first arm's cfg; got: {fallback_cfg}"
    );
    assert!(
        norm.contains(&normalize_cfg(r#"not(feature = "ner-onnx")"#)),
        "fallback gate must reference the second arm's cfg; got: {fallback_cfg}"
    );
}

/// A single gated arm plus an ungated fallback re-gates to `not(<that cfg>)` without the `any(...)`
/// wrapper.
#[test]
fn single_gated_arm_regates_without_any_wrapper() {
    let input = vec![
        make_fn(
            "download_model",
            "krate::download_model",
            Some(r#"feature = "ner""#),
            &[],
        ),
        make_fn("download_model", "krate::download_model", None, &[]),
    ];

    let out = regate_ungated_same_name_functions(&input);

    assert_eq!(out.len(), 2);
    assert_eq!(out[0].cfg.as_deref(), Some(r#"feature = "ner""#));
    assert_eq!(
        out[1].cfg.as_deref(),
        Some(r#"not(feature = "ner")"#),
        "single-arm fallback must be gated as not(<cfg>) with no any(...) wrapper"
    );
}

/// Disjoint gated arms with NO ungated fallback are left completely untouched — they are already
/// mutually exclusive and Rustler compiles exactly one.
#[test]
fn leaves_purely_gated_disjoint_arms_untouched() {
    let input = vec![
        make_fn(
            "default_model_name",
            "krate::default_model_name",
            Some(r#"feature = "ner-onnx""#),
            &[],
        ),
        make_fn(
            "default_model_name",
            "krate::default_model_name",
            Some(r#"not(feature = "ner-onnx")"#),
            &[],
        ),
    ];

    let out = regate_ungated_same_name_functions(&input);

    assert_eq!(out.len(), 2);
    assert_eq!(out[0].cfg.as_deref(), Some(r#"feature = "ner-onnx""#));
    assert_eq!(out[1].cfg.as_deref(), Some(r#"not(feature = "ner-onnx")"#));
}

/// A unique ungated function is not a duplicate hazard and must pass through unchanged.
#[test]
fn leaves_unique_ungated_function_untouched() {
    let input = vec![make_fn("extract_bytes", "krate::extract_bytes", None, &["bytes"])];
    let out = regate_ungated_same_name_functions(&input);
    assert_eq!(out.len(), 1);
    assert!(
        out[0].cfg.is_none(),
        "a unique ungated function must remain unconditional"
    );
}

/// Two ungated entries with the same name (no gated arm) are left untouched — there is no gated cfg
/// to anchor a `not(...)` against, so this pass does not invent one.
#[test]
fn leaves_all_ungated_group_untouched() {
    let input = vec![
        make_fn("known_models", "krate::known_models", None, &[]),
        make_fn("known_models", "krate::known_models", None, &[]),
    ];
    let out = regate_ungated_same_name_functions(&input);
    assert_eq!(out.len(), 2);
    assert!(out.iter().all(|f| f.cfg.is_none()));
}

/// The pass preserves the relative order of every entry and only mutates `cfg`.
#[test]
fn preserves_order_and_only_mutates_cfg() {
    let input = vec![
        make_fn("before", "krate::before", None, &[]),
        make_fn(
            "known_models",
            "krate::known_models",
            Some(r#"feature = "ner-onnx""#),
            &[],
        ),
        make_fn("known_models", "krate::known_models", None, &[]),
        make_fn("after", "krate::after", None, &[]),
    ];

    let out = regate_ungated_same_name_functions(&input);

    let names: Vec<&str> = out.iter().map(|f| f.name.as_str()).collect();
    assert_eq!(names, vec!["before", "known_models", "known_models", "after"]);
    assert!(out[0].cfg.is_none(), "unrelated `before` stays ungated");
    assert!(out[3].cfg.is_none(), "unrelated `after` stays ungated");
    assert_eq!(out[2].cfg.as_deref(), Some(r#"not(feature = "ner-onnx")"#));
}

/// The pass is a pure transformation — it must not mutate the input slice.
#[test]
fn does_not_mutate_input() {
    let input = vec![
        make_fn(
            "known_models",
            "krate::known_models",
            Some(r#"feature = "ner-onnx""#),
            &[],
        ),
        make_fn("known_models", "krate::known_models", None, &[]),
    ];
    let snapshot = input.clone();

    let _ = regate_ungated_same_name_functions(&input);

    for (before, after) in snapshot.iter().zip(input.iter()) {
        assert_eq!(before.cfg, after.cfg, "input cfg must be untouched");
    }
}