Skip to main content

rustjava_runtime/classes/java/lang/
class.rs

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
18// class java.lang.Class
19pub 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                // Stored as raw bytes instead of java/lang/String to avoid circular dependency:
71                // from_rust_class -> JavaLangString::from_rust_string -> new_class("java/lang/String") -> from_rust_class -> stack overflow
72                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            // TODO ClassLoader.getSystemResourceAsStream?
308            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}