Autogenerate proxy java classes.

Author: Dirbaio

java-spaghetti-gen/src/config.rs

@@ -5,7 +5,7 @@ use std::{fs, io};
 
 use serde_derive::Deserialize;
 
-fn default_proxy_path_prefix() -> String {
+fn default_proxy_package() -> String {
     "java_spaghetti/proxy".to_string()
 }
 
@@ -170,17 +170,19 @@ pub struct ClassConfig<'a> {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Config {
-    #[serde(default = "default_proxy_path_prefix")]
-    pub proxy_path_prefix: String,
+    pub input: Vec<PathBuf>,
+    pub output: PathBuf,
 
-    pub(crate) input: Vec<PathBuf>,
-    pub(crate) output: PathBuf,
+    #[serde(default = "default_proxy_package")]
+    pub proxy_package: String,
+    #[serde(default)]
+    pub proxy_output: Option<PathBuf>,
 
     #[serde(default)]
-    pub(crate) logging_verbose: bool,
+    pub logging_verbose: bool,
 
     #[serde(default)]
-    pub(crate) rules: Vec<Rule>,
+    pub rules: Vec<Rule>,
 }
 
 impl Config {
@@ -207,6 +209,9 @@ impl Config {
         }
 
         config.output = resolve_file(&config.output, dir);
+        if let Some(proxy_output) = &mut config.proxy_output {
+            *proxy_output = resolve_file(proxy_output, dir);
+        }
         for f in &mut config.input {
             *f = resolve_file(f, dir);
         }

java-spaghetti-gen/src/emit/class_proxy.rs

@@ -32,7 +32,7 @@ impl Class {
 
         let java_proxy_path = format!(
             "{}/{}",
-            context.config.proxy_path_prefix,
+            context.config.proxy_package,
             self.java.path().as_str().replace("$", "_")
         );
 

java-spaghetti-gen/src/emit/java_proxy.rs

@@ -0,0 +1,199 @@
+use std::fmt::Write;
+use std::path::Path;
+
+use cafebabe::descriptors::{FieldDescriptor, FieldType, ReturnDescriptor};
+
+use super::classes::Class;
+use super::methods::Method;
+use crate::emit::Context;
+
+impl Class {
+    pub(crate) fn write_java_proxy(&self, context: &Context, methods: &[Method]) -> anyhow::Result<String> {
+        let java_proxy_path = format!(
+            "{}/{}",
+            context.config.proxy_package,
+            self.java.path().as_str().replace("$", "_")
+        );
+
+        let package_name = java_proxy_path.rsplit_once('/').map(|x| x.0).unwrap_or("");
+        let class_name = java_proxy_path.split('/').next_back().unwrap();
+
+        let mut w = String::new();
+
+        // Package declaration
+        if !package_name.is_empty() {
+            writeln!(w, "package {};", package_name.replace("/", "."))?;
+            writeln!(w)?;
+        }
+
+        // Class declaration
+        let parent_type = if self.java.is_interface() {
+            "implements"
+        } else {
+            "extends"
+        };
+
+        writeln!(w, "@SuppressWarnings(\"rawtypes\")")?;
+
+        writeln!(
+            w,
+            "class {} {} {} {{",
+            class_name,
+            parent_type,
+            self.java.path().as_str().replace('/', ".")
+        )?;
+
+        // ptr field
+        writeln!(w, "    long ptr;")?;
+        writeln!(w)?;
+
+        // Constructor
+        writeln!(w, "    private {class_name}(long ptr) {{")?;
+        writeln!(w, "        this.ptr = ptr;")?;
+        writeln!(w, "    }}")?;
+        writeln!(w)?;
+
+        // Finalize method
+        writeln!(w, "    @Override")?;
+        writeln!(w, "    protected void finalize() throws Throwable {{")?;
+        writeln!(w, "        native_finalize(this.ptr);")?;
+        writeln!(w, "    }}")?;
+        writeln!(w, "    private native void native_finalize(long ptr);")?;
+        writeln!(w)?;
+
+        // Generate methods
+        for method in methods {
+            let Some(_rust_name) = method.rust_name() else { continue };
+            if method.java.is_static()
+                || method.java.is_static_init()
+                || method.java.is_constructor()
+                || method.java.is_final()
+                || method.java.is_private()
+            {
+                continue;
+            }
+
+            let method_name = method.java.name();
+
+            // Method signature
+            let return_type = match &method.java.descriptor.return_type {
+                ReturnDescriptor::Void => "void".to_string(),
+                ReturnDescriptor::Return(desc) => java_type_name(desc)?,
+            };
+
+            let mut params = Vec::new();
+            for (i, param) in method.java.descriptor.parameters.iter().enumerate() {
+                let param_type = java_type_name(param)?;
+                params.push(format!("{param_type} arg{i}"));
+            }
+
+            writeln!(w, "    @Override")?;
+            writeln!(
+                w,
+                "    public {} {}({}) {{",
+                return_type,
+                method_name,
+                params.join(", ")
+            )?;
+
+            // Method body - call native method
+            let native_method_name = format!("native_{method_name}");
+            let mut args = vec!["ptr".to_string()];
+            for i in 0..method.java.descriptor.parameters.len() {
+                args.push(format!("arg{i}"));
+            }
+
+            if return_type == "void" {
+                writeln!(w, "        {}({});", native_method_name, args.join(", "))?;
+            } else {
+                writeln!(w, "        return {}({});", native_method_name, args.join(", "))?;
+            }
+            writeln!(w, "    }}")?;
+
+            // Native method declaration
+            let mut native_params = vec!["long ptr".to_string()];
+            for (i, param) in method.java.descriptor.parameters.iter().enumerate() {
+                let param_type = java_type_name(param)?;
+                native_params.push(format!("{param_type} arg{i}"));
+            }
+
+            writeln!(
+                w,
+                "    private native {} {}({});",
+                return_type,
+                native_method_name,
+                native_params.join(", ")
+            )?;
+            writeln!(w)?;
+        }
+
+        writeln!(w, "}}")?;
+
+        Ok(w)
+    }
+}
+
+fn java_type_name(desc: &FieldDescriptor) -> anyhow::Result<String> {
+    let mut result = String::new();
+
+    let base_type = match &desc.field_type {
+        FieldType::Byte => "byte",
+        FieldType::Char => "char",
+        FieldType::Double => "double",
+        FieldType::Float => "float",
+        FieldType::Integer => "int",
+        FieldType::Long => "long",
+        FieldType::Short => "short",
+        FieldType::Boolean => "boolean",
+        FieldType::Object(path) => {
+            // Convert JNI path to Java path
+            return Ok(format!(
+                "{}{}",
+                path.replace('/', "."),
+                "[]".repeat(desc.dimensions as usize)
+            ));
+        }
+    };
+
+    result.push_str(base_type);
+
+    // Add array dimensions
+    for _ in 0..desc.dimensions {
+        result.push_str("[]");
+    }
+
+    Ok(result)
+}
+
+pub fn write_java_proxy_files(context: &Context, output_dir: &Path) -> anyhow::Result<()> {
+    for (_, class) in context.all_classes.iter() {
+        let cc = context.config.resolve_class(class.java.path().as_str());
+        if !cc.proxy {
+            continue;
+        }
+
+        // Collect methods for this class
+        let mut methods = Vec::new();
+        methods.extend(class.java.methods().map(|m| Method::new(&class.java, m)));
+
+        let java_code = class.write_java_proxy(context, &methods)?;
+
+        // Calculate output file path
+        let java_proxy_path = class.java.path().as_str().replace("$", "_");
+
+        let relative_path = format!("{java_proxy_path}.java");
+        let output_file = output_dir.join(&relative_path);
+
+        // Create directory if it doesn't exist
+        if let Some(parent) = output_file.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+
+        // Write Java file
+        std::fs::write(&output_file, java_code)?;
+
+        println!("Generated Java proxy: {}", output_file.display());
+    }
+
+    Ok(())
+}

java-spaghetti-gen/src/emit/mod.rs

@@ -3,6 +3,7 @@
 mod class_proxy;
 mod classes;
 mod fields;
+pub mod java_proxy;
 mod known_docs_url;
 mod methods;
 mod modules;

java-spaghetti-gen/src/main.rs

@@ -32,6 +32,11 @@ pub fn run(config: impl Into<Config>) -> Result<(), Box<dyn Error>> {
     context.write(&mut out)?;
     util::write_generated(&context, &config.output, &out[..])?;
 
+    // Generate Java proxy files if proxy_output is specified
+    if let Some(proxy_output) = &config.proxy_output {
+        emit::java_proxy::write_java_proxy_files(&context, proxy_output)?;
+    }
+
     Ok(())
 }