Emit MethodParameters attribute to allow Java tools to show function argument names cleanly (credit: mipastgt for the idea!)

IntegralPilot · IntegralPilot · commit 9b2836360b06 · 2025-11-02T11:17:57.000+11:00
diff --git a/Tester.py b/Tester.py
@@ -6,8 +6,11 @@
 import glob
 
 # A constant for the base classpath needed by both test types
-# NOTE: You may need to update the kotlin version in the future
-RUNTIME_CLASSPATH_BASE = "library/build/distributions/library-0.1.0/lib/library-0.1.0.jar:library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar"
+# NOTE: We may need to update the kotlin version in the future
+RUNTIME_CLASSPATH_BASE = os.pathsep.join([
+    "library/build/distributions/library-0.1.0/lib/library-0.1.0.jar",
+    "library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar",
+])
 
 def read_from_file(path: str) -> str:
     with open(path, "r") as f:
diff --git a/proguard/default.pro b/proguard/default.pro
@@ -4,4 +4,6 @@
 }
 -keepclassmembers class * implements * {
     <methods>;
-}
+}
+
+-keepattributes MethodParameters
diff --git a/src/lib.rs b/src/lib.rs
@@ -427,12 +427,12 @@ impl CodegenBackend for MyBackend {
                     // Replace self references with the trait name as to match signatures with the one we've put on the interface
                     if of_trait.is_some() {
                         match oomir_function.signature.params.get(0) {
-                            Some(Type::Class(name)) => {
+                            Some((param_name, Type::Class(name))) => {
                                 if *name != ident {
                                     continue;
                                 }
                                 oomir_function.signature.params[0] =
-                                    Type::Class(of_trait.clone().unwrap());
+                                    (param_name.clone(), Type::Class(of_trait.clone().unwrap()));
 
                                 // insert a Cast instruction to cast the trait (interface) object to the specific type of this class
                                 // this is needed because the method signature will be different than what MIR expects
@@ -456,12 +456,15 @@ impl CodegenBackend for MyBackend {
                                     );
                                 }
                             }
-                            Some(Type::MutableReference(box Type::Class(name))) => {
+                            Some((param_name, Type::MutableReference(box Type::Class(name)))) => {
                                 if *name != ident {
                                     continue;
                                 }
-                                oomir_function.signature.params[0] = Type::MutableReference(
-                                    Box::new(Type::Class(of_trait.clone().unwrap())),
+                                oomir_function.signature.params[0] = (
+                                    param_name.clone(),
+                                    Type::MutableReference(
+                                        Box::new(Type::Class(of_trait.clone().unwrap())),
+                                    ),
                                 );
 
                                 // insert a Cast instruction to cast the trait (interface) object to the specific type of this class
@@ -500,23 +503,23 @@ impl CodegenBackend for MyBackend {
                         let mut new_params = vec![];
                         // replace any MutableReference(Class(of_trait)) or Class(of_trait) with MutableReference(Class(ident))/ Class(ident)
                         // this is just for the helper function, the actual method will use oomir_function.signature and we're only modifying helper_sig
-                        for arg in &oomir_function.signature.params {
-                            if let Type::MutableReference(box Type::Class(name)) = arg {
+                        for (param_name, param_ty) in &oomir_function.signature.params {
+                            if let Type::MutableReference(box Type::Class(name)) = param_ty {
                                 if *name == of_trait.clone().unwrap() {
-                                    new_params.push(Type::MutableReference(Box::new(Type::Class(
+                                    new_params.push((param_name.clone(), Type::MutableReference(Box::new(Type::Class(
                                         ident.clone(),
-                                    ))));
+                                    )))));
                                 } else {
-                                    new_params.push(arg.clone());
+                                    new_params.push((param_name.clone(), param_ty.clone()));
                                 }
-                            } else if let Type::Class(name) = arg {
+                            } else if let Type::Class(name) = param_ty {
                                 if *name == of_trait.clone().unwrap() {
-                                    new_params.push(Type::Class(ident.clone()));
+                                    new_params.push((param_name.clone(), Type::Class(ident.clone())));
                                 } else {
-                                    new_params.push(arg.clone());
+                                    new_params.push((param_name.clone(), param_ty.clone()));
                                 }
                             } else {
-                                new_params.push(arg.clone());
+                                new_params.push((param_name.clone(), param_ty.clone()));
                             }
                         }
                         helper_sig.params = new_params;
@@ -531,12 +534,11 @@ impl CodegenBackend for MyBackend {
                     let mut instructions = vec![];
 
                     let mut idx = 1;
-                    for arg in &oomir_function.signature.params {
+                    for (_param_name, param_ty) in &oomir_function.signature.params {
                         let arg_name = format!("_{idx}");
-                        let arg_ty = arg.clone();
                         let arg = Operand::Variable {
                             name: arg_name.clone(),
-                            ty: arg_ty,
+                            ty: param_ty.clone(),
                         };
                         args.push(arg);
                         idx += 1;
@@ -723,16 +725,22 @@ impl CodegenBackend for MyBackend {
                     let data_types = &mut HashMap::new(); // Consider if this should be shared across loop iterations or functions
 
                     // Use skip_binder here too, as inputs/outputs are bound by the same binder as the fn_sig
-                    let params_oomir_ty: Vec<oomir::Type> = params_ty
+                    let params_oomir: Vec<(String, oomir::Type)> = params_ty
                         .skip_binder()
                         .iter()
-                        .map(|ty| lower1::types::ty_to_oomir_type(*ty, tcx, data_types))
+                        .enumerate()
+                        .map(|(i, ty)| {
+                            // For trait methods, we don't have MIR, so use generic names
+                            let param_name = format!("arg{}", i);
+                            let oomir_type = lower1::types::ty_to_oomir_type(*ty, tcx, data_types);
+                            (param_name, oomir_type)
+                        })
                         .collect();
                     let return_oomir_ty: oomir::Type =
                         lower1::types::ty_to_oomir_type(return_ty.skip_binder(), tcx, data_types);
 
                     let mut signature = oomir::Signature {
-                        params: params_oomir_ty,
+                        params: params_oomir,
                         ret: Box::new(return_oomir_ty.clone()),
                     };
                     signature.replace_class_in_signature("Self", &ident);
@@ -741,9 +749,8 @@ impl CodegenBackend for MyBackend {
 
                     let mut args = vec![];
                     let mut idx = 1;
-                    for arg in signature.clone().params {
+                    for (_arg_name_from_sig, arg_ty) in signature.clone().params {
                         let arg_name = format!("_{idx}");
-                        let arg_ty = arg.clone();
                         let arg = Operand::Variable {
                             name: arg_name.clone(),
                             ty: arg_ty,
diff --git a/src/lower1.rs b/src/lower1.rs
@@ -71,15 +71,38 @@ pub fn mir_to_oomir<'tcx>(
 
     let data_types = &mut HashMap::new();
 
-    let params_oomir_ty: Vec<oomir::Type> = params_ty
+    let params_oomir: Vec<(String, oomir::Type)> = params_ty
         .skip_binder()
         .iter()
-        .map(|ty| ty_to_oomir_type(*ty, tcx, data_types))
+        .enumerate()
+        .map(|(i, ty)| {
+            // Arguments start at MIR local 1. The index `i` starts at 0.
+            let local_index = rustc_middle::mir::Local::from_usize(i + 1);
+            
+            // Try to find the parameter name from var_debug_info
+            let param_name = mir.var_debug_info
+                .iter()
+                .find_map(|var_info| {
+                    // Check if this debug info entry is for our parameter
+                    if let rustc_middle::mir::VarDebugInfoContents::Place(place) = &var_info.value {
+                        if place.local == local_index && place.projection.is_empty() {
+                            return Some(var_info.name.to_string());
+                        }
+                    }
+                    None
+                })
+                .unwrap_or_else(|| format!("arg{}", i));
+                
+            let oomir_type = ty_to_oomir_type(*ty, tcx, data_types);
+            
+            // Return the (name, type) tuple
+            (param_name, oomir_type)
+        })
         .collect();
     let return_oomir_ty: oomir::Type = ty_to_oomir_type(return_ty.skip_binder(), tcx, data_types);
 
     let mut signature = oomir::Signature {
-        params: params_oomir_ty,
+        params: params_oomir,
         ret: Box::new(return_oomir_ty.clone()), // Clone here to pass to convert_basic_block
     };
 
@@ -91,9 +114,9 @@ pub fn mir_to_oomir<'tcx>(
             if fn_name == "main" {
                 // manually override the signature to match the JVM main method
                 signature = oomir::Signature {
-                    params: vec![oomir::Type::Array(Box::new(oomir::Type::Class(
+                    params: vec![("args".to_string(), oomir::Type::Array(Box::new(oomir::Type::Class(
                         "java/lang/String".to_string(),
-                    )))],
+                    ))))],
                     ret: Box::new(oomir::Type::Void),
                 };
             }
@@ -132,7 +155,7 @@ pub fn mir_to_oomir<'tcx>(
         // But we receive: local 1 = tuple containing all args
 
         // Get the tuple parameter type (should be the first parameter in the signature)
-        if let Some(tuple_param_ty) = signature.params.first() {
+        if let Some((_tuple_param_name, tuple_param_ty)) = signature.params.first() {
             // Check if it's a tuple/struct type that we need to unpack
             if let oomir::Type::Class(class_name) = tuple_param_ty {
                 // Get the data type definition to see its fields
diff --git a/src/lower2.rs b/src/lower2.rs
@@ -78,6 +78,21 @@ pub fn oomir_to_jvm_bytecode(
                 attributes: Vec::new(),
             };
 
+            // Create MethodParameters attribute to preserve parameter names
+            let mut parameters_for_attribute = Vec::new();
+            for (name, _) in &function.signature.params {
+                let name_index = main_cp.add_utf8(name)?;
+                parameters_for_attribute.push(jvm::attributes::MethodParameter {
+                    name_index,
+                    access_flags: MethodAccessFlags::empty(), // No special flags
+                });
+            }
+            let method_parameters_attribute_name_index = main_cp.add_utf8("MethodParameters")?;
+            let method_parameters_attribute = Attribute::MethodParameters {
+                name_index: method_parameters_attribute_name_index,
+                parameters: parameters_for_attribute,
+            };
+
             let mut method = jvm::Method::default();
             // Assume static for now, adjust if instance methods are needed
             method.access_flags = MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC;
@@ -88,6 +103,11 @@ pub fn oomir_to_jvm_bytecode(
             method.name_index = name_index;
             method.descriptor_index = descriptor_index;
             method.attributes.push(code_attribute);
+            // Add MethodParameters attribute (skip for constructors as they often have synthetic params)
+            if function.name != "<init>" {
+                println!("Adding MethodParameters attribute for function: {}: {:?}", function.name, method_parameters_attribute);
+                method.attributes.push(method_parameters_attribute);
+            }
 
             methods.push(method);
         }
diff --git a/src/lower2/consts.rs b/src/lower2/consts.rs
@@ -221,7 +221,11 @@ pub fn load_constant(
             // 2. Determine constructor parameter types and signature descriptor
             let param_types = params
                 .iter()
-                .map(Type::from_constant) // Get oomir::Type from each oomir::Constant
+                .enumerate()
+                .map(|(i, const_val)| {
+                    let ty = Type::from_constant(const_val);
+                    (format!("arg{}", i), ty)
+                })
                 .collect::<Vec<_>>();
 
             let constructor_signature = Signature {
diff --git a/src/lower2/jvm_gen.rs b/src/lower2/jvm_gen.rs
@@ -205,16 +205,37 @@ pub(super) fn create_data_type_classfile_for_class(
                     attributes: Vec::new(),
                 };
 
+                // Create MethodParameters attribute to preserve parameter names
+                let mut parameters_for_attribute = Vec::new();
+                for (name, _) in &function.signature.params {
+                    let name_index = class_file.constant_pool.add_utf8(name)?;
+                    parameters_for_attribute.push(jvm::attributes::MethodParameter {
+                        name_index,
+                        access_flags: MethodAccessFlags::empty(), // No special flags
+                    });
+                }
+                let method_parameters_attribute_name_index = class_file.constant_pool.add_utf8("MethodParameters")?;
+                let method_parameters_attribute = Attribute::MethodParameters {
+                    name_index: method_parameters_attribute_name_index,
+                    parameters: parameters_for_attribute,
+                };
+
                 let name_index = class_file.constant_pool.add_utf8(method_name)?;
                 let descriptor_index = class_file
                     .constant_pool
                     .add_utf8(&function.signature.to_string())?;
 
+                let mut attributes_vec = vec![code_attribute];
+                // Skip MethodParameters for constructors and getVariantIdx
+                if method_name != "<init>" && method_name != "getVariantIdx" {
+                    attributes_vec.push(method_parameters_attribute);
+                }
+
                 let jvm_method = jvm::Method {
                     access_flags: MethodAccessFlags::PUBLIC,
                     name_index,
                     descriptor_index,
-                    attributes: vec![code_attribute],
+                    attributes: attributes_vec,
                 };
 
                 class_file.methods.push(jvm_method);
@@ -256,7 +277,7 @@ pub(super) fn create_data_type_classfile_for_interface(
     for (method_name, signature) in methods {
         // Construct the descriptor: (param1_desc param2_desc ...)return_desc
         let mut descriptor = String::from("(");
-        for param_type in &signature.params {
+        for (_param_name, param_type) in &signature.params {
             descriptor.push_str(&param_type.to_jvm_descriptor());
         }
         descriptor.push(')');
diff --git a/src/lower2/translator.rs b/src/lower2/translator.rs
@@ -70,7 +70,7 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
             let param_translator_name = format!("param_{}", i);
             // The name used in the OOMIR body, corresponding to MIR convention (_1, _2, ...)
             let param_oomir_name = format!("_{}", i + 1);
-            let param_ty = &oomir_func.signature.params[i];
+            let (_param_name, param_ty) = &oomir_func.signature.params[i];
 
             // Use assign_local to allocate the slot using the *translator* name first.
             // This ensures the slot is reserved and next_local_index advances correctly.
diff --git a/src/oomir.rs b/src/oomir.rs
@@ -188,7 +188,7 @@ pub struct Function {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Signature {
-    pub params: Vec<Type>,
+    pub params: Vec<(String, Type)>,
     pub ret: Box<Type>,
 }
 
@@ -197,7 +197,7 @@ impl Signature {
     /// in the signature's parameters and return type.
     pub fn replace_class_in_signature(&mut self, old_class_name: &str, new_class_name: &str) {
         // Replace in parameters
-        for param_type in self.params.iter_mut() {
+        for (_param_name, param_type) in self.params.iter_mut() {
             param_type.replace_class(old_class_name, new_class_name);
         }
 
@@ -211,8 +211,8 @@ impl Signature {
     pub fn to_string(&self) -> String {
         let mut result = String::new();
         result.push('(');
-        for param in &self.params {
-            result.push_str(&param.to_jvm_descriptor());
+        for (_param_name, param_type) in &self.params {
+            result.push_str(&param_type.to_jvm_descriptor());
         }
         result.push(')');
         result.push_str(&self.ret.to_jvm_descriptor());
@@ -958,7 +958,7 @@ impl Type {
 impl fmt::Display for Signature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "(")?;
-        for param_ty in &self.params {
+        for (_param_name, param_ty) in &self.params {
             write!(f, "{}", param_ty.to_jvm_descriptor())?;
         }
         write!(f, "){}", self.ret.to_jvm_descriptor())

Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,6 @@`
`4`	`4`	`}`
`5`	`5`	`-keepclassmembers class * implements * {`
`6`	`6`	`<methods>;`
`7`		`-}`
	`7`	`+}`
	`8`	`+`
	`9`	`+-keepattributes MethodParameters`