passes: gate step-2 renames on the virtual family index (fixes override-chain split)

crates/noxis-passes/tests/family.rs

@@ -0,0 +1,105 @@
+//! Virtual-family integrity: a package-private override chain must be
+//! renamed as one family, never member by member.
+//!
+//! `method_rename_safety` used to classify package-private overrides as
+//! `Safe` (its subclass check never fired: `declaring_chain` only walks
+//! upwards). The individual renames then split one family into different
+//! names, and the JVM failed at dispatch with `AbstractMethodError`
+//! (real case: shaded gson `ReflectionHelper$RecordHelper.isRecord`).
+
+#![allow(clippy::expect_used, clippy::unwrap_used)]
+
+use noxis_classfile::{ClassBuilder, Code, Const, Insn, Method, Prim, Program, Version};
+use noxis_core::{Config, Context, Pass, RenameConfig};
+use noxis_passes::RenamePass;
+
+fn check_code() -> Code {
+    Code {
+        max_stack: 1,
+        max_locals: 2,
+        insns: vec![Insn::Const(Const::Int(1)), Insn::Return(Some(Prim::Int))],
+        exception_table: Vec::new(),
+        frames: Vec::new(),
+        attributes: Vec::new(),
+    }
+}
+
+/// `demo/Base` declares package-private abstract `check(LClass;)Z`;
+/// `demo/ImplA`/`demo/ImplB` override it.
+fn sample() -> Program {
+    let mut base = ClassBuilder::new("demo/Base", Some("java/lang/Object"))
+        .version(Version::JAVA_21)
+        .build();
+    base.methods.push(Method {
+        access_flags: 0x0400, // abstract, package-private
+        name: "check".to_string(),
+        descriptor: "(Ljava/lang/Class;)Z".to_string(),
+        code: None,
+        attributes: Vec::new(),
+    });
+    let impl_a = ClassBuilder::new("demo/ImplA", Some("demo/Base"))
+        .version(Version::JAVA_21)
+        .method_with_code(0x0000, "check", "(Ljava/lang/Class;)Z", check_code())
+        .build();
+    let impl_b = ClassBuilder::new("demo/ImplB", Some("demo/Base"))
+        .version(Version::JAVA_21)
+        .method_with_code(0x0000, "check", "(Ljava/lang/Class;)Z", check_code())
+        .build();
+    Program {
+        classes: vec![base, impl_a, impl_b],
+        resources: Vec::new(),
+    }
+}
+
+fn run(program: &mut Program, rename_public_members: bool) {
+    let config = Config {
+        seed: Some(7),
+        rename: RenameConfig {
+            rename_public_members,
+            ..RenameConfig::default()
+        },
+        ..Config::default()
+    };
+    let mut ctx = Context::new(config);
+    RenamePass.apply(&mut ctx, program).expect("rename pass");
+}
+
+/// The three `check(LClass;)Z` methods after the pass: one shared name.
+fn family_names(program: &Program) -> Vec<String> {
+    let mut out = Vec::new();
+    for class in &program.classes {
+        for method in &class.methods {
+            if method.descriptor == "(Ljava/lang/Class;)Z" {
+                out.push(method.name.clone());
+            }
+        }
+    }
+    out
+}
+
+#[test]
+fn package_private_override_chain_renames_as_one_family() {
+    let mut program = sample();
+    run(&mut program, true);
+
+    let names = family_names(&program);
+    assert_eq!(names.len(), 3, "all three overrides must be present");
+    assert!(
+        names.iter().all(|name| name == &names[0]),
+        "one family - one name, got {names:?}"
+    );
+    assert_ne!(names[0], "check", "the family must actually be renamed");
+}
+
+#[test]
+fn package_private_overrides_stay_consistent_without_public_rename() {
+    let mut program = sample();
+    run(&mut program, false);
+
+    let names = family_names(&program);
+    assert_eq!(names.len(), 3, "all three overrides must be present");
+    assert!(
+        names.iter().all(|name| name == &names[0]),
+        "families off must keep the chain untouched, got {names:?}"
+    );
+}