Emit attribute to enable idiomatic subclass (i.e. enum variant) access from Java. Added an integration test to verify this.

Author: IntegralPilot

Tester.py

@@ -127,7 +127,17 @@ def process_binary_test(test_dir: str, release_mode: bool) -> bool:
     test_name = os.path.basename(test_dir)
     normalized = normalize_name(test_name)
     print(f"|-- Test '{test_name}' ({normalized})")
-    
+
+    # If running in release mode, allow tests to opt-out by creating a
+    # `no_release.flag` file containing a short justification. When present
+    # we skip the test and show the justification to the user.
+    no_release_file = os.path.join(test_dir, "no_release.flag")
+    if release_mode and os.path.exists(no_release_file):
+        reason = read_from_file(no_release_file).strip()
+        # Per request: show the justification when skipping
+        print(f"Skipping: {reason}")
+        return True
+
     print("|--- 🧼 Cleaning test folder...")
     proc = run_command(["cargo", "clean"], cwd=test_dir)
     if proc.returncode != 0:
@@ -159,6 +169,16 @@ def process_integration_test(test_dir: str, release_mode: bool) -> bool:
     normalized = normalize_name(test_name)
     print(f"|-- Test '{test_name}' ({normalized})")
 
+    # If running in release mode, allow tests to opt-out by creating a
+    # `no_release.flag` file containing a short justification. When present
+    # we skip the test and show the justification to the user.
+    no_release_file = os.path.join(test_dir, "no_release.flag")
+    if release_mode and os.path.exists(no_release_file):
+        reason = read_from_file(no_release_file).strip()
+        # Per request: show the justification when skipping
+        print(f"Skipping: {reason}")
+        return True
+
     print("|--- 🧼 Cleaning test folder...")
     run_command(["cargo", "clean"], cwd=test_dir) # Ignore clean failure for now
 

proguard/default.pro

@@ -1,9 +1,11 @@
--keep public class * { public static void main(java.lang.String[]); }
+-keep public class *
 -keep class * {
     <fields>;
 }
 -keepclassmembers class * implements * {
     <methods>;
 }
 
--keepattributes MethodParameters
+-keepattributes MethodParameters
+-keepattributes InnerClasses
+-keepattributes EnclosingMethod

src/lower2.rs

@@ -172,6 +172,12 @@ pub fn oomir_to_jvm_bytecode(
                 methods,
                 interfaces,
             } => {
+                let mut subclasses = Vec::new();
+                for (other_dt_name, _) in &module.data_types {
+                    if other_dt_name.starts_with(&format!("{}$", dt_name_oomir)) {
+                        subclasses.push(other_dt_name.clone());
+                    }
+                }
                 // Create and serialize the class file for this data type
                 let dt_bytecode = create_data_type_classfile_for_class(
                     &dt_name_oomir,
@@ -181,6 +187,7 @@ pub fn oomir_to_jvm_bytecode(
                     super_class.as_deref().unwrap_or("java/lang/Object"),
                     interfaces.clone(),
                     &module,
+                    subclasses,
                 )?;
                 generated_classes.insert(dt_name_oomir.clone(), dt_bytecode);
             }

src/lower2/jvm_gen.rs

@@ -6,7 +6,7 @@ use crate::oomir::{self, DataTypeMethod, Signature, Type};
 use ristretto_classfile::{
     self as jvm, BaseType, ClassAccessFlags, ClassFile, ConstantPool, FieldAccessFlags,
     MethodAccessFlags, Version,
-    attributes::{Attribute, Instruction, MaxStack},
+    attributes::{Attribute, Instruction, MaxStack, InnerClass, NestedClassAccessFlags},
 };
 use std::collections::HashMap;
 
@@ -91,6 +91,7 @@ pub(super) fn create_data_type_classfile_for_class(
     super_class_name_jvm: &str,
     implements_interfaces: Vec<String>,
     module: &oomir::Module,
+    subclasses: Vec<String>,
 ) -> jvm::Result<Vec<u8>> {
     let mut cp = ConstantPool::default();
 
@@ -244,6 +245,51 @@ pub(super) fn create_data_type_classfile_for_class(
         }
     }
 
+    // --- Add InnerClasses Attribute (for nested/member classes) ---
+    if !subclasses.is_empty() {
+        let mut inner_classes_vec: Vec<InnerClass> = Vec::with_capacity(subclasses.len());
+
+        for subclass_name in &subclasses {
+            // Ensure subclass class_info is in the constant pool
+            let class_info_index = class_file.constant_pool.add_class(subclass_name)?;
+
+            // The outer class is this class
+            let outer_class_info_index = class_file.this_class;
+
+            // Derive simple name: part after last '$'. If there's no '$', treat as unnamed (0).
+            let simple_name_part = subclass_name.rsplit('$').next().unwrap_or(subclass_name);
+
+            // If the simple name looks like an anonymous class (all digits), set name_index = 0
+            let name_index = if simple_name_part.chars().all(|c| c.is_ascii_digit()) {
+                0
+            } else if simple_name_part == *subclass_name && !subclass_name.contains('$') {
+                // No '$' present -> not an inner/member class; leave name_index = 0
+                0
+            } else {
+                class_file
+                    .constant_pool
+                    .add_utf8(simple_name_part)?
+            };
+
+            // Default to PUBLIC | STATIC for generated nested classes. This can be adjusted
+            // if more precise access info becomes available.
+            let access_flags = NestedClassAccessFlags::PUBLIC | NestedClassAccessFlags::STATIC;
+
+            inner_classes_vec.push(InnerClass {
+                class_info_index,
+                outer_class_info_index,
+                name_index,
+                access_flags,
+            });
+        }
+
+        let inner_classes_attr_name_index = class_file.constant_pool.add_utf8("InnerClasses")?;
+        class_file.attributes.push(Attribute::InnerClasses {
+            name_index: inner_classes_attr_name_index,
+            classes: inner_classes_vec,
+        });
+    }
+
     // --- Add SourceFile Attribute ---
     let simple_name = class_name_jvm.split('/').last().unwrap_or(class_name_jvm);
     let source_file_name = format!("{}.rs", simple_name);

tests/integration/inner_classes/.cargo/config.toml

@@ -0,0 +1 @@
+../../../../config.toml

tests/integration/inner_classes/Cargo.lock

@@ -0,0 +1,8 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "inner_classes"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

tests/integration/inner_classes/Cargo.toml

@@ -0,0 +1,24 @@
+public class Main {
+    public static void main(String[] args) {
+        TrafficLight red = new TrafficLight.Red();
+        TrafficLight yellow = new TrafficLight.Yellow();
+        TrafficLight green = new TrafficLight.Green();
+
+        String redAction = inner_classes.get_light_action(red);
+        if (!redAction.equals("Stop")) {
+             throw new AssertionError("Test failed for Red: expected 'Stop' but got '" + redAction + "'");
+        }
+
+        String yellowAction = inner_classes.get_light_action(yellow);
+        if (!yellowAction.equals("Caution")) {
+             throw new AssertionError("Test failed for Yellow: expected 'Caution' but got '" + yellowAction + "'");
+        }
+
+        String greenAction = inner_classes.get_light_action(green);
+        if (!greenAction.equals("Go")) {
+             throw new AssertionError("Test failed for Green: expected 'Go' but got '" + greenAction + "'");
+        }
+
+        System.out.println("Inner class access test passed!");
+    }
+}

tests/integration/inner_classes/Main.java

@@ -0,0 +1 @@
+enum variants we want to test will get optimised away.

tests/integration/inner_classes/no_release.flag

@@ -0,0 +1,19 @@
+pub enum TrafficLight {
+    Red,
+    Yellow,
+    Green,
+}
+
+pub fn get_light_action(light: TrafficLight) -> &'static str {
+    match light {
+        TrafficLight::Red => "Stop",
+        TrafficLight::Yellow => "Caution",
+        TrafficLight::Green => "Go",
+    }
+}
+
+pub fn main() {
+    assert!(get_light_action(TrafficLight::Red) == "Stop");
+    assert!(get_light_action(TrafficLight::Yellow) == "Caution");
+    assert!(get_light_action(TrafficLight::Green) == "Go");
+}