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, "java/lang/Class", "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> =
259 jvm.get_field(&this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await?;
260 if defining_loader.is_null() {
261 return Ok(jvm.resolve_class(component_name).await?.java_class().into());
262 }
263
264 let component_name = JavaLangString::from_rust_string(jvm, component_name).await?;
265 jvm.invoke_virtual(
266 &defining_loader,
267 "java/lang/ClassLoader",
268 "loadClass",
269 "(Ljava/lang/String;)Ljava/lang/Class;",
270 (component_name,),
271 )
272 .await
273 }
274
275 async fn get_interfaces(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<jvm::Array<Self>>> {
276 tracing::debug!("java.lang.Class::getInterfaces({this:?})");
277
278 let name = JavaLangClass::name(jvm, &this).await?;
279 let interface_names = if matches!(
280 name.as_str(),
281 "boolean" | "byte" | "char" | "short" | "int" | "long" | "float" | "double" | "void"
282 ) {
283 vec![]
284 } else {
285 JavaLangClass::to_rust_class(jvm, &this).await?.interface_names()
286 };
287
288 let mut interfaces = jvm.instantiate_array("Ljava/lang/Class;", interface_names.len()).await?;
289 for (index, interface_name) in interface_names.iter().enumerate() {
290 let interface = jvm.resolve_class(interface_name).await?.java_class();
291 jvm.store_array(&mut interfaces, index, [interface]).await?;
292 }
293
294 Ok(interfaces.into())
295 }
296
297 async fn get_resource_as_stream(
298 jvm: &Jvm,
299 _context: &mut RuntimeContext,
300 this: ClassInstanceRef<Self>,
301 name: ClassInstanceRef<String>,
302 ) -> Result<ClassInstanceRef<InputStream>> {
303 tracing::debug!("java.lang.Class::getResourceAsStream({this:?}, {name:?})");
304
305 let class_loader: ClassInstanceRef<ClassLoader> = jvm.get_field(&this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await?;
306
307 let class_loader = if class_loader.is_null() {
308 JavaLangClassLoader::get_system_class_loader(jvm).await?
310 } else {
311 class_loader.into()
312 };
313
314 jvm.invoke_virtual(
315 &class_loader,
316 "java/lang/ClassLoader",
317 "getResourceAsStream",
318 "(Ljava/lang/String;)Ljava/io/InputStream;",
319 (name,),
320 )
321 .await
322 }
323
324 async fn for_name(jvm: &Jvm, _context: &mut RuntimeContext, name: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Class>> {
325 tracing::debug!("java.lang.Class::forName({name:?})");
326
327 if name.is_null() {
328 return Err(jvm.exception("java/lang/NullPointerException", "name").await);
329 }
330
331 let rust_name = JavaLangString::to_rust_string(jvm, &name).await?;
332 let qualified_name = rust_name.replace('.', "/");
333
334 match jvm.resolve_class(&qualified_name).await {
335 Ok(class) => Ok(class.java_class().into()),
336 Err(_) => Err(jvm.exception("java/lang/ClassNotFoundException", &rust_name).await),
337 }
338 }
339}