alef 0.106.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

use crate::codegen::naming::{go_param_name, go_type_name, to_go_name};
use crate::core::ir::TypeRef;

/// The DTO field a streaming adapter's Go wrapper decomposes into a single ergonomic scalar
/// parameter, when it does.
///
/// Mirrors the exact condition [`gen_adapter_wrapper`] renders from: exactly one configured
/// `[[adapters]] params` entry whose declared type resolves (in `types`) to an IR struct with
/// at least one field. `None` covers every shape `gen_adapter_wrapper`'s non-decomposing branch
/// handles instead -- zero or multiple configured params, a param type absent from `types`, or
/// a fieldless struct -- so Go exposes `adapter.params` unchanged in every one of those. Exposed
/// (`pub(crate)`) so e2e/snippet argument rendering can ask this question directly instead of
/// re-deriving its own copy of the same test, which is how the Java/C# streaming-request bug
/// happened in the first place. ~keep
pub(crate) fn adapter_flattened_field<'a>(
    adapter: &crate::core::config::AdapterConfig,
    types: &'a [crate::core::ir::TypeDef],
) -> Option<&'a crate::core::ir::FieldDef> {
    if adapter.request_type.is_none() || adapter.params.len() != 1 {
        return None;
    }
    let param_ty_name = &adapter.params[0].ty;
    types.iter().find(|t| &t.name == param_ty_name)?.fields.first()
}

/// Emit a module-level wrapper function for a streaming adapter.
/// This allows tests/consumers to call pkg.CrawlStream(engine, url) instead of engine.CrawlStream(url).
/// For adapters with a request_type, decompose the first field into primitive parameters for ergonomics.
pub(in crate::backends::go::gen_bindings) fn gen_adapter_wrapper(
    adapter: &crate::core::config::AdapterConfig,
    _pkg_name: &str,
    types: &[crate::core::ir::TypeDef],
) -> String {
    let adapter_name = &adapter.name;
    let go_func_name = to_go_name(adapter_name);
    let owner_type_raw = adapter.owner_type.as_deref().unwrap_or_else(|| {
        panic!(
            "go adapter `{adapter_name}`: streaming adapter requires `owner_type` in `[[adapters]]` config (the Rust handle type that owns the streaming method)"
        )
    });
    // `methods.rs` declares the receiver type (and the `<Recv><Method>Stream` iterator it
    // returns) by running the IR type name through `go_type_name`. `[[adapters]] owner_type` is a
    // plain config string with nothing upstream normalizing it, so this wrapper must apply the
    // same helper before using it as either a Go type reference or a Stream-type name component
    // -- otherwise a configured value containing an initialism (`ApiClient`, `HttpEngine`, ...)
    // names an identifier `methods.rs` never declares. See #447. ~keep
    let owner_type = go_type_name(owner_type_raw);
    let owner_type = owner_type.as_str();
    // The Stream type name comes from the owning method's own wrapper (see
    // `gen_streaming_method_wrapper`), not from `item_type` directly, but `item_type` is still
    // required config for the adapter as a whole, so the presence check stays here.
    let _item_type = adapter.item_type.as_deref().unwrap_or_else(|| {
        panic!(
            "go adapter `{adapter_name}`: streaming adapter requires `item_type` in `[[adapters]]` config (the Rust item type yielded by the stream)"
        )
    });

    let request_type = adapter.request_type.as_deref().unwrap_or_else(|| {
        panic!(
            "go adapter `{adapter_name}`: streaming adapter requires `request_type` in `[[adapters]]` config (the Rust request payload type)"
        )
    });
    let request_type_simple = request_type.rsplit("::").next().unwrap_or(request_type);

    let (param_parts, request_construction) = if let Some(first_field) = adapter_flattened_field(adapter, types) {
        let field_name = &first_field.name;
        let field_name_go = to_go_name(field_name);

        let go_field_type = match &first_field.ty {
            TypeRef::String => "string".to_string(),
            TypeRef::Vec(inner) if matches!(**inner, TypeRef::String) => "[]string".to_string(),
            TypeRef::Vec(_) => "[]interface{}".to_string(),
            other => crate::backends::go::type_map::go_type(other).into_owned(),
        };

        let wrapper_params = vec![
            format!("engine *{owner_type}"),
            format!("{field_name_go} {go_field_type}"),
        ];

        let struct_field_name = to_go_name(field_name);
        let construction = format!("req := &{request_type_simple}{{{struct_field_name}: {field_name_go}}}\n\t");

        (wrapper_params, Some(construction))
    } else {
        let mut params = vec![format!("engine *{owner_type}")];
        for p in &adapter.params {
            let go_param_type = match p.ty.as_str() {
                "String" => "string".to_string(),
                ty => ty.rsplit("::").next().unwrap_or(ty).to_string(),
            };
            let param_name = go_param_name(&p.name);
            params.push(format!("{param_name} {go_param_type}"));
        }
        (params, None)
    };

    let method_call_name = to_go_name(adapter_name);
    let stream_type_name = format!("{owner_type}{method_call_name}Stream");
    let context_return_type = format!("*{stream_type_name}, error");
    let item_type = go_type_name(_item_type.rsplit("::").next().unwrap_or(_item_type));
    let compatibility_return_type = format!("<-chan {item_type}, error");
    let method_call = if request_construction.is_some() {
        format!("engine.{}WithContext(ctx, *req)", method_call_name)
    } else {
        let param_args = adapter
            .params
            .iter()
            .map(|p| go_param_name(&p.name))
            .collect::<Vec<_>>()
            .join(", ");
        if param_args.is_empty() {
            format!("engine.{}WithContext(ctx)", method_call_name)
        } else {
            format!("engine.{}WithContext(ctx, {})", method_call_name, param_args)
        }
    };

    let context_params = std::iter::once("ctx context.Context".to_string())
        .chain(param_parts.iter().cloned())
        .collect::<Vec<_>>()
        .join(", ");
    let compatibility_args = std::iter::once("context.Background()".to_string())
        .chain(std::iter::once("engine".to_string()))
        .chain(adapter_flattened_field(adapter, types).map(|field| to_go_name(&field.name)))
        .chain(if adapter_flattened_field(adapter, types).is_some() {
            Vec::new()
        } else {
            adapter.params.iter().map(|p| go_param_name(&p.name)).collect()
        })
        .collect::<Vec<_>>()
        .join(", ");

    crate::backends::go::template_env::render(
        "adapter_wrapper.jinja",
        minijinja::context! {
            go_func_name => &go_func_name,
            go_func_with_context_name => format!("{go_func_name}WithContext"),
            owner_type => owner_type,
            method_call_name => &method_call_name,
            params => param_parts.join(", "),
            context_params => &context_params,
            compatibility_args => &compatibility_args,
            compatibility_return_type => &compatibility_return_type,
            context_return_type => &context_return_type,
            request_construction => request_construction.as_deref(),
            method_call => &method_call,
        },
    )
}