alef 0.25.37

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

use super::helpers::rust_to_go_type;
use crate::core::ir::{MethodDef, TypeDef, TypeRef};
use heck::ToPascalCase;

/// Generate the Go interface method signature for a trait method.
pub(super) fn gen_interface_method(out: &mut String, method: &MethodDef) {
    let mut params = Vec::new();
    for p in &method.params {
        let go_type = rust_to_go_type(&p.ty);
        params.push(format!("{} {}", p.name, go_type));
    }

    let return_type = if method.error_type.is_some() {
        match &method.return_type {
            TypeRef::Unit => "error".to_string(),
            _ => {
                let ret = rust_to_go_type(&method.return_type);
                format!("({}, error)", ret)
            }
        }
    } else {
        rust_to_go_type(&method.return_type)
    };

    let params_str = params.join(", ");
    out.push_str(&crate::backends::go::template_env::render(
        "trait_interface_method.jinja",
        minijinja::context! {
            doc => &method.name,
            method_name => method.name.to_pascal_case(),
            params => params_str,
            return_type => return_type,
        },
    ));
    out.push('\n');
}

/// Generate the Path A Bridge struct and its methods.
///
/// The Bridge struct wraps a user-implemented interface and delegates all trait method calls to it.
/// This pattern allows Go's structural interface satisfaction to work with hand-authored plugin
/// interfaces that may not match the auto-generated trait interface exactly.
pub(super) fn gen_bridge_wrapper(
    out: &mut String,
    trait_def: &TypeDef,
    trait_name: &str,
    ffi_skip_methods: &[String],
    excluded_named_types: &std::collections::HashSet<&str>,
) {
    let trait_pascal = trait_name.to_pascal_case();
    let bridge_name = format!("{}Bridge", trait_pascal);

    // Emit Bridge struct definition with impl field
    out.push_str(&format!(
        "// {}Bridge wraps a {} implementation and exposes it to the C plugin system.\n",
        trait_pascal, trait_name
    ));
    out.push_str(&format!("type {} struct {{\n", bridge_name));
    out.push_str(&format!("\timpl {}\n", trait_name));
    out.push_str("}\n\n");

    // Emit constructor
    out.push_str(&format!(
        "// New{} creates a new Bridge wrapping the given implementation.\n",
        bridge_name
    ));
    out.push_str(&format!(
        "func New{}(impl {}) *{} {{\n",
        bridge_name, trait_name, bridge_name
    ));
    out.push_str(&format!("\treturn &{}{{impl: impl}}\n", bridge_name));
    out.push_str("}\n\n");

    // Emit delegating methods for plugin lifecycle
    gen_bridge_lifecycle_method(out, &bridge_name, "Name", "string");
    gen_bridge_lifecycle_method(out, &bridge_name, "Version", "string");
    gen_bridge_lifecycle_method(out, &bridge_name, "Initialize", "error");
    gen_bridge_lifecycle_method(out, &bridge_name, "Shutdown", "error");

    // Emit delegating methods for trait-specific methods
    for method in &trait_def.methods {
        if ffi_skip_methods.contains(&method.name) {
            continue;
        }
        gen_bridge_trait_method(out, &bridge_name, method, excluded_named_types);
    }
}

/// Generate a delegating bridge method for plugin lifecycle methods.
fn gen_bridge_lifecycle_method(out: &mut String, bridge_name: &str, method_name: &str, return_type: &str) {
    out.push_str(&format!(
        "func (b *{}) {}() {} {{\n",
        bridge_name, method_name, return_type
    ));
    out.push_str(&format!("\treturn b.impl.{}()\n", method_name));
    out.push_str("}\n\n");
}

/// Generate a delegating bridge method for a trait method.
fn gen_bridge_trait_method(
    out: &mut String,
    bridge_name: &str,
    method: &MethodDef,
    excluded_named_types: &std::collections::HashSet<&str>,
) {
    let method_pascal = method.name.to_pascal_case();
    let mut params = Vec::new();
    for p in &method.params {
        let go_type = rust_to_go_type_with_excluded(&p.ty, excluded_named_types);
        params.push(format!("{} {}", p.name, go_type));
    }

    let return_type = if method.error_type.is_some() {
        match &method.return_type {
            TypeRef::Unit => "error".to_string(),
            _ => {
                let ret = rust_to_go_type_with_excluded(&method.return_type, excluded_named_types);
                format!("({}, error)", ret)
            }
        }
    } else {
        rust_to_go_type_with_excluded(&method.return_type, excluded_named_types)
    };

    let params_str = params.join(", ");
    let params_call = method
        .params
        .iter()
        .map(|p| p.name.clone())
        .collect::<Vec<_>>()
        .join(", ");

    out.push_str(&format!(
        "func (b *{}) {}({}) {} {{\n",
        bridge_name, method_pascal, params_str, return_type
    ));
    out.push_str(&format!("\treturn b.impl.{}({})\n", method_pascal, params_call));
    out.push_str("}\n\n");
}

/// Map a TypeRef to Go type, handling excluded types as json.RawMessage.
fn rust_to_go_type_with_excluded(ty: &TypeRef, excluded_named_types: &std::collections::HashSet<&str>) -> String {
    match ty {
        TypeRef::Named(name) if excluded_named_types.contains(name.as_str()) => "json.RawMessage".to_string(),
        _ => rust_to_go_type(ty),
    }
}