108 lines
3.4 KiB
Rust
108 lines
3.4 KiB
Rust
//! Code-level round trips that the IR must survive.
|
|
|
|
use noxis_classfile::Insn;
|
|
use noxis_classfile::format;
|
|
use ristretto_classfile::attributes::{Attribute as RtAttr, Instruction as Rt};
|
|
use ristretto_classfile::{
|
|
ClassAccessFlags, ClassFile as RtClass, ConstantPool, JAVA_21, Method as RtMethod,
|
|
MethodAccessFlags,
|
|
};
|
|
|
|
/// `invokestatic` on an *interface* method (`List.of`) needs a
|
|
/// `CONSTANT_InterfaceMethodref`: writing a plain `Methodref` passes the
|
|
/// verifier's structural check but HotSpot rejects the linkage with
|
|
/// `IncompatibleClassChangeError` at first call.
|
|
#[test]
|
|
fn invokestatic_interface_method_ref_round_trip() {
|
|
let mut pool = ConstantPool::default();
|
|
let this = pool.add_class("demo/IfStatic").expect("this");
|
|
let object = pool.add_class("java/lang/Object").expect("object");
|
|
let name = pool.add_utf8("main").expect("name");
|
|
let desc = pool.add_utf8("([Ljava/lang/String;)V").expect("desc");
|
|
let code_name = pool.add_utf8("Code").expect("code name");
|
|
let list_class = pool.add_class("java/util/List").expect("list");
|
|
let of = pool
|
|
.add_interface_method_ref(
|
|
list_class,
|
|
"of",
|
|
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/List;",
|
|
)
|
|
.expect("interface ref");
|
|
|
|
let code = vec![
|
|
Rt::Aload_0,
|
|
Rt::Aload_0,
|
|
Rt::Invokestatic(of),
|
|
Rt::Pop,
|
|
Rt::Return,
|
|
];
|
|
let rt = RtClass {
|
|
version: JAVA_21,
|
|
constant_pool: pool,
|
|
access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::SUPER,
|
|
this_class: this,
|
|
super_class: object,
|
|
interfaces: vec![],
|
|
fields: vec![],
|
|
methods: vec![RtMethod {
|
|
access_flags: MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
|
|
name_index: name,
|
|
descriptor_index: desc,
|
|
attributes: vec![RtAttr::Code {
|
|
name_index: code_name,
|
|
max_stack: 2,
|
|
max_locals: 1,
|
|
code,
|
|
exception_table: vec![],
|
|
attributes: vec![],
|
|
}],
|
|
}],
|
|
attributes: vec![],
|
|
..RtClass::default()
|
|
};
|
|
|
|
let mut original = Vec::new();
|
|
rt.to_bytes(&mut original).expect("to_bytes");
|
|
let parsed = format::parse(&original).expect("parse");
|
|
let method = &parsed.methods[0];
|
|
let invoke = method
|
|
.code
|
|
.as_ref()
|
|
.expect("code")
|
|
.insns
|
|
.iter()
|
|
.find_map(|i| match i {
|
|
Insn::Invoke {
|
|
kind, owner, itf, ..
|
|
} => Some((*kind, owner.clone(), *itf)),
|
|
_ => None,
|
|
})
|
|
.expect("invokestatic");
|
|
assert!(invoke.2, "parse must keep the interface flag");
|
|
|
|
let written = format::write(&parsed).expect("write");
|
|
let reparsed = format::parse(&written).expect("re-parse");
|
|
let method = &reparsed.methods[0];
|
|
let invoke = method
|
|
.code
|
|
.as_ref()
|
|
.expect("code")
|
|
.insns
|
|
.iter()
|
|
.find_map(|i| match i {
|
|
Insn::Invoke {
|
|
kind, owner, itf, ..
|
|
} => Some((*kind, owner.clone(), *itf)),
|
|
_ => None,
|
|
})
|
|
.expect("invokestatic");
|
|
assert_eq!(
|
|
invoke,
|
|
(
|
|
noxis_classfile::InvokeKind::Static,
|
|
"java/util/List".to_string(),
|
|
true
|
|
),
|
|
"InterfaceMethodref must survive write"
|
|
);
|
|
}
|