1use alloc::vec;
2
3use jvm::{
4 ClassInstanceRef, JavaType, Jvm, Result,
5 runtime::{JavaLangClass, JavaLangClassLoader, JavaLangString},
6};
7use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
8use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
9
10use crate::{
11 RuntimeClassProto, RuntimeContext,
12 classes::java::{
13 io::InputStream,
14 lang::{ClassLoader, Object, String},
15 },
16};
17
18pub struct Class;
20
21impl Class {
22 pub fn as_proto() -> RuntimeClassProto {
23 RuntimeClassProto {
24 name: "java/lang/Class",
25 parent_class: Some("java/lang/Object"),
26 interfaces: vec!["java/io/Serializable"],
27 methods: vec![
28 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PRIVATE),
29 JavaMethodProto::new("getName", "()Ljava/lang/String;", Self::get_name, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new("isPrimitive", "()Z", Self::is_primitive, MethodAccessFlags::PUBLIC),
31 JavaMethodProto::new("isArray", "()Z", Self::is_array, MethodAccessFlags::PUBLIC),
32 JavaMethodProto::new("isInterface", "()Z", Self::is_interface, MethodAccessFlags::PUBLIC),
33 JavaMethodProto::new("isInstance", "(Ljava/lang/Object;)Z", Self::is_instance, MethodAccessFlags::PUBLIC),
34 JavaMethodProto::new(
35 "isAssignableFrom",
36 "(Ljava/lang/Class;)Z",
37 Self::is_assignable_from,
38 MethodAccessFlags::PUBLIC | MethodAccessFlags::NATIVE,
39 ),
40 JavaMethodProto::new("newInstance", "()Ljava/lang/Object;", Self::new_instance, MethodAccessFlags::PUBLIC),
41 JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
42 JavaMethodProto::new("getSuperclass", "()Ljava/lang/Class;", Self::get_superclass, MethodAccessFlags::PUBLIC),
43 JavaMethodProto::new(
44 "getClassLoader",
45 "()Ljava/lang/ClassLoader;",
46 Self::get_class_loader,
47 MethodAccessFlags::PUBLIC,
48 ),
49 JavaMethodProto::new(
50 "getComponentType",
51 "()Ljava/lang/Class;",
52 Self::get_component_type,
53 MethodAccessFlags::PUBLIC,
54 ),
55 JavaMethodProto::new("getInterfaces", "()[Ljava/lang/Class;", Self::get_interfaces, MethodAccessFlags::PUBLIC),
56 JavaMethodProto::new(
57 "getResourceAsStream",
58 "(Ljava/lang/String;)Ljava/io/InputStream;",
59 Self::get_resource_as_stream,
60 MethodAccessFlags::PUBLIC,
61 ),
62 JavaMethodProto::new(
63 "forName",
64 "(Ljava/lang/String;)Ljava/lang/Class;",
65 Self::for_name,
66 MethodAccessFlags::STATIC,
67 ),
68 ],
69 fields: vec![
70 JavaFieldProto::new("nameBytes", "[B", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
73 JavaFieldProto::new(
74 "classLoader",
75 "Ljava/lang/ClassLoader;",
76 FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
77 ),
78 ],
79 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
80 }
81 }
82
83 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
84 tracing::debug!("java.lang.Class::<init>({this:?})");
85
86 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
87
88 Ok(())
89 }
90
91 async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
92 tracing::debug!("java.lang.Class::getName({this:?})");
93
94 let class_name = JavaLangClass::name(jvm, &this).await?;
95 let result = JavaLangString::from_rust_string(jvm, &class_name.replace('/', ".")).await?;
96
97 Ok(result.into())
98 }
99
100 async fn is_primitive(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
101 let name = JavaLangClass::name(jvm, &this).await?;
102 Ok(matches!(
103 name.as_str(),
104 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double"
105 ))
106 }
107
108 async fn is_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
109 let name = JavaLangClass::name(jvm, &this).await?;
110 Ok(name.starts_with('['))
111 }
112
113 async fn is_interface(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
114 let name = JavaLangClass::name(jvm, &this).await?;
115 if name.starts_with('[') || matches!(name.as_str(), "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double") {
116 return Ok(false);
117 }
118
119 let class = JavaLangClass::to_rust_class(jvm, &this).await?;
120 Ok(class.access_flags().contains(ClassAccessFlags::INTERFACE))
121 }
122
123 async fn is_instance(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, object: ClassInstanceRef<Object>) -> Result<bool> {
124 if object.is_null() {
125 return Ok(false);
126 }
127
128 let name = JavaLangClass::name(jvm, &this).await?;
129 if matches!(name.as_str(), "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double") {
130 return Ok(false);
131 }
132
133 Ok(jvm.is_instance(&**object, &name))
134 }
135
136 async fn new_instance(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
137 let name = JavaLangClass::name(jvm, &this).await?;
138 if name.starts_with('[') || matches!(name.as_str(), "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double") {
139 return Err(jvm.exception("java/lang/InstantiationException", &name).await);
140 }
141
142 let class = JavaLangClass::to_rust_class(jvm, &this).await?;
143 let access_flags = class.access_flags();
144 if access_flags.contains(ClassAccessFlags::INTERFACE)
145 || access_flags.contains(ClassAccessFlags::ABSTRACT)
146 || class.method("<init>", "()V", false).is_none()
147 {
148 return Err(jvm.exception("java/lang/InstantiationException", &name).await);
149 }
150
151 let instance = jvm.instantiate_class(&name).await?;
152 let _: () = jvm.invoke_special(&instance, &name, "<init>", "()V", ()).await?;
153
154 Ok(instance.into())
155 }
156
157 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
158 let name = JavaLangClass::name(jvm, &this).await?;
159 let text = if matches!(name.as_str(), "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double") {
160 name
161 } else {
162 let class = JavaLangClass::to_rust_class(jvm, &this).await?;
163 let prefix = if class.access_flags().contains(ClassAccessFlags::INTERFACE) {
164 "interface "
165 } else {
166 "class "
167 };
168 alloc::format!("{prefix}{}", name.replace('/', "."))
169 };
170
171 Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
172 }
173
174 async fn is_assignable_from(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<bool> {
175 tracing::debug!("java.lang.Class::isAssignableFrom({this:?}, {other:?})");
176
177 if other.is_null() {
178 return Err(jvm.exception("java/lang/NullPointerException", "other").await);
179 }
180
181 let class_name = JavaLangClass::name(jvm, &this).await?;
182 let other_name = JavaLangClass::name(jvm, &other).await?;
183 let class_is_primitive = matches!(
184 class_name.as_str(),
185 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double"
186 );
187 let other_is_primitive = matches!(
188 other_name.as_str(),
189 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double"
190 );
191
192 if class_is_primitive || other_is_primitive {
193 return Ok(class_name == other_name);
194 }
195
196 Ok(jvm.is_type_assignable(&JavaType::from_class_name(&other_name), &JavaType::from_class_name(&class_name)))
197 }
198
199 async fn get_superclass(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
200 tracing::debug!("java.lang.Class::getSuperclass({this:?})");
201
202 let name = JavaLangClass::name(jvm, &this).await?;
203 if matches!(
204 name.as_str(),
205 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double" | "void" | "java/lang/Object"
206 ) {
207 return Ok(None.into());
208 }
209 if name.starts_with('[') {
210 return Ok(jvm.resolve_class("java/lang/Object").await?.java_class().into());
211 }
212
213 let class = JavaLangClass::to_rust_class(jvm, &this).await?;
214 if class.access_flags().contains(ClassAccessFlags::INTERFACE) {
215 return Ok(None.into());
216 }
217
218 match class.super_class_name() {
219 Some(super_class_name) => Ok(jvm.resolve_class(&super_class_name).await?.java_class().into()),
220 None => Ok(None.into()),
221 }
222 }
223
224 async fn get_class_loader(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<ClassLoader>> {
225 tracing::debug!("java.lang.Class::getClassLoader({this:?})");
226
227 jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await
228 }
229
230 async fn get_component_type(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
231 tracing::debug!("java.lang.Class::getComponentType({this:?})");
232
233 let name = JavaLangClass::name(jvm, &this).await?;
234 let Some(component_descriptor) = name.strip_prefix('[') else {
235 return Ok(None.into());
236 };
237
238 let primitive_wrapper = match component_descriptor {
239 "Z" => Some("java/lang/Boolean"),
240 "B" => Some("java/lang/Byte"),
241 "C" => Some("java/lang/Character"),
242 "S" => Some("java/lang/Short"),
243 "I" => Some("java/lang/Integer"),
244 "J" => Some("java/lang/Long"),
245 "F" => Some("java/lang/Float"),
246 "D" => Some("java/lang/Double"),
247 _ => None,
248 };
249 if let Some(wrapper) = primitive_wrapper {
250 return jvm.get_static_field(wrapper, "TYPE", "Ljava/lang/Class;").await;
251 }
252
253 let component_name = if let Some(reference_name) = component_descriptor.strip_prefix('L').and_then(|name| name.strip_suffix(';')) {
254 reference_name
255 } else {
256 component_descriptor
257 };
258 let defining_loader: ClassInstanceRef<ClassLoader> = jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await?;
259 if defining_loader.is_null() {
260 return Ok(jvm.resolve_class(component_name).await?.java_class().into());
261 }
262
263 let component_name = JavaLangString::from_rust_string(jvm, component_name).await?;
264 jvm.invoke_virtual(
265 &defining_loader,
266 "java/lang/ClassLoader",
267 "loadClass",
268 "(Ljava/lang/String;)Ljava/lang/Class;",
269 (component_name,),
270 )
271 .await
272 }
273
274 async fn get_interfaces(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<jvm::Array<Self>>> {
275 tracing::debug!("java.lang.Class::getInterfaces({this:?})");
276
277 let name = JavaLangClass::name(jvm, &this).await?;
278 let interface_names = if matches!(
279 name.as_str(),
280 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double" | "void"
281 ) {
282 vec![]
283 } else {
284 JavaLangClass::to_rust_class(jvm, &this).await?.interface_names()
285 };
286
287 let mut interfaces = jvm.instantiate_array("Ljava/lang/Class;", interface_names.len()).await?;
288 for (index, interface_name) in interface_names.iter().enumerate() {
289 let interface = jvm.resolve_class(interface_name).await?.java_class();
290 jvm.store_array(&mut interfaces, index, [interface]).await?;
291 }
292
293 Ok(interfaces.into())
294 }
295
296 async fn get_resource_as_stream(
297 jvm: &Jvm,
298 _context: &mut RuntimeContext,
299 this: ClassInstanceRef<Self>,
300 name: ClassInstanceRef<String>,
301 ) -> Result<ClassInstanceRef<InputStream>> {
302 tracing::debug!("java.lang.Class::getResourceAsStream({this:?}, {name:?})");
303
304 let class_loader: ClassInstanceRef<ClassLoader> = jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await?;
305
306 let class_loader = if class_loader.is_null() {
307 JavaLangClassLoader::get_system_class_loader(jvm).await?
309 } else {
310 class_loader.into()
311 };
312
313 jvm.invoke_virtual(
314 &class_loader,
315 "java/lang/ClassLoader",
316 "getResourceAsStream",
317 "(Ljava/lang/String;)Ljava/io/InputStream;",
318 (name,),
319 )
320 .await
321 }
322
323 async fn for_name(jvm: &Jvm, _context: &mut RuntimeContext, name: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Class>> {
324 tracing::debug!("java.lang.Class::forName({name:?})");
325
326 if name.is_null() {
327 return Err(jvm.exception("java/lang/NullPointerException", "name").await);
328 }
329
330 let rust_name = JavaLangString::to_rust_string(jvm, &name).await?;
331 let qualified_name = rust_name.replace('.', "/");
332
333 match jvm.resolve_class(&qualified_name).await {
334 Ok(class) => Ok(class.java_class().into()),
335 Err(_) => Err(jvm.exception("java/lang/ClassNotFoundException", &rust_name).await),
336 }
337 }
338}