alef 0.25.53

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

//! Regression coverage for host-native capsule (Language-passthrough) generation in the Java
//! facade. The raw FFI class already constructs the host runtime's `Language`; the facade must
//! declare that same host type as its return so the delegating `return raw.method(...)` body
//! compiles. Without the fix the facade declared the package-local opaque `Language`, producing
//! `incompatible types: io.github.treesitter.jtreesitter.Language cannot be converted to ...`.

use alef::backends::java::JavaBackend;
use alef::core::backend::Backend;
use alef::core::config::{NewAlefConfig, ResolvedCrateConfig};
use alef::core::ir::{ApiSurface, FunctionDef, TypeRef};

fn capsule_function(name: &str) -> FunctionDef {
    FunctionDef {
        name: name.to_string(),
        rust_path: format!("tree_sitter::{name}"),
        original_rust_path: String::new(),
        params: vec![],
        return_type: TypeRef::Named("Language".to_string()),
        error_type: None,
        is_async: false,
        doc: "Get a language grammar.".to_string(),
        cfg: None,
        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 api_with_capsule(fn_name: &str) -> ApiSurface {
    ApiSurface {
        crate_name: "tree_sitter".to_string(),
        version: "0.25.0".to_string(),
        types: vec![],
        functions: vec![capsule_function(fn_name)],
        enums: vec![],
        errors: vec![],
        services: vec![],
        excluded_type_paths: std::collections::HashMap::new(),
        excluded_trait_names: std::collections::HashSet::new(),
        handler_contracts: vec![],
        unsupported_public_items: vec![],
    }
}

fn resolved_one(toml: &str) -> ResolvedCrateConfig {
    let cfg: NewAlefConfig = toml::from_str(toml).unwrap();
    cfg.resolve().unwrap().remove(0)
}

/// The generated facade class is the public wrapper (main class without the `Rs` suffix).
fn facade_content(files: &[alef::core::backend::GeneratedFile]) -> String {
    let file = files.iter().find(|f| {
        let path = f.path.to_string_lossy();
        path.ends_with(".java") && f.content.contains("public static") && f.content.contains("getLanguage")
    });

    if let Some(f) = file {
        f.content.clone()
    } else {
        // Debug: list all generated files
        let mut debug_msg = String::from("facade class containing getLanguage not found\nGenerated files:\n");
        for f in files {
            debug_msg.push_str(&format!("  {}\n", f.path.display()));
        }
        panic!("{}", debug_msg);
    }
}

#[test]
fn facade_declares_configured_host_capsule_return_type() {
    let api = api_with_capsule("get_language");
    let config = resolved_one(
        r#"
[workspace]
languages = ["java", "ffi"]

[[crates]]
name = "tree_sitter"
sources = ["src/lib.rs"]

[crates.ffi]
prefix = "tree_sitter"
error_style = "last_error"

[crates.java]
package = "dev.kreuzberg.treesitterlanguagepack"

[crates.java.capsule_types.Language]
host_type = "io.github.treesitter.jtreesitter.Language"
package = "io.github.tree-sitter:jtreesitter"
package_version = "0.26.0"
construct_expr = "new io.github.treesitter.jtreesitter.Language({ptr})"
"#,
    );

    let files = JavaBackend
        .generate_bindings(&api, &config)
        .expect("Java generation failed");
    let content = facade_content(&files);

    assert!(
        content.contains("io.github.treesitter.jtreesitter.Language getLanguage"),
        "facade should declare the host capsule return type. Content:\n{content}"
    );
    // The buggy form declared the package-local opaque handle as the return type.
    assert!(
        !content.contains("static Language getLanguage"),
        "facade must not declare the opaque local Language as the return type. Content:\n{content}"
    );
}

#[test]
fn facade_falls_back_to_opaque_handle_without_capsule_config() {
    let api = api_with_capsule("get_language");
    let config = resolved_one(
        r#"
[workspace]
languages = ["java", "ffi"]

[[crates]]
name = "tree_sitter"
sources = ["src/lib.rs"]

[crates.ffi]
prefix = "tree_sitter"
error_style = "last_error"

[crates.java]
package = "dev.kreuzberg.treesitterlanguagepack"
"#,
    );

    let files = JavaBackend
        .generate_bindings(&api, &config)
        .expect("Java generation failed");
    let content = facade_content(&files);

    assert!(
        content.contains("static Language getLanguage"),
        "without capsule config the facade keeps the opaque local Language return. Content:\n{content}"
    );
}