From 4d00f2151c669d136bc04da04906e6c3dbb44473 Mon Sep 17 00:00:00 2001 From: Inseok Lee Date: Thu, 24 Sep 2026 08:35:40 +0900 Subject: [PATCH 1/2] Fix instance field resolution and storage across inheritance --- jvm-bytecode/src/class_definition.rs | 8 +++- jvm-bytecode/src/field.rs | 18 ++++----- jvm-bytecode/src/interpreter.rs | 5 ++- jvm/src/jvm.rs | 53 ++++++++++++++++++++------- test-data/Field$Base.class | Bin 0 -> 507 bytes test-data/Field$Derived.class | Bin 0 -> 472 bytes test-data/Field$Leaf.class | Bin 0 -> 253 bytes test-data/Field.class | Bin 649 -> 1197 bytes test-data/Field.txt | 8 ++++ test-data/src/Field.java | 46 +++++++++++++++++++++++ 10 files changed, 109 insertions(+), 29 deletions(-) create mode 100644 test-data/Field$Base.class create mode 100644 test-data/Field$Derived.class create mode 100644 test-data/Field$Leaf.class diff --git a/jvm-bytecode/src/class_definition.rs b/jvm-bytecode/src/class_definition.rs index 1d920fa8..5764ceed 100644 --- a/jvm-bytecode/src/class_definition.rs +++ b/jvm-bytecode/src/class_definition.rs @@ -83,7 +83,11 @@ impl ClassDefinitionImpl { .map(|x| MethodImpl::from_method_proto(x, context.clone())) .collect::>(); - let fields = proto.fields.into_iter().map(FieldImpl::from_field_proto).collect::>(); + let fields = proto + .fields + .into_iter() + .map(|field| FieldImpl::from_field_proto(proto.name, field)) + .collect::>(); let interfaces = proto.interfaces.into_iter().map(|x| x.to_string()).collect(); @@ -111,7 +115,7 @@ impl ClassDefinitionImpl { _ => None, }); - let field = FieldImpl::from_field_info(field_info); + let field = FieldImpl::from_field_info(&class.this_class, field_info); if let Some(x) = constant && field.access_flags().contains(FieldAccessFlags::STATIC) { diff --git a/jvm-bytecode/src/field.rs b/jvm-bytecode/src/field.rs index b342b558..304ba4b9 100644 --- a/jvm-bytecode/src/field.rs +++ b/jvm-bytecode/src/field.rs @@ -11,6 +11,7 @@ use jvm_types::FieldAccessFlags; #[derive(Debug, Eq, PartialEq, Ord, PartialOrd)] struct FieldInner { + declaring_class: String, name: String, descriptor: String, access_flags: FieldAccessFlags, @@ -22,9 +23,10 @@ pub struct FieldImpl { } impl FieldImpl { - pub fn new(name: &str, descriptor: &str, access_flags: FieldAccessFlags) -> Self { + pub fn new(declaring_class: &str, name: &str, descriptor: &str, access_flags: FieldAccessFlags) -> Self { Self { inner: Arc::new(FieldInner { + declaring_class: declaring_class.to_string(), name: name.to_string(), descriptor: descriptor.to_string(), access_flags, @@ -32,18 +34,12 @@ impl FieldImpl { } } - pub fn from_field_proto(proto: JavaFieldProto) -> Self { - Self::new(&proto.name, &proto.descriptor, proto.access_flags) + pub fn from_field_proto(declaring_class: &str, proto: JavaFieldProto) -> Self { + Self::new(declaring_class, &proto.name, &proto.descriptor, proto.access_flags) } - pub fn from_field_info(field_info: FieldInfo) -> Self { - Self { - inner: Arc::new(FieldInner { - name: field_info.name.to_string(), - descriptor: field_info.descriptor.to_string(), - access_flags: field_info.access_flags, - }), - } + pub fn from_field_info(declaring_class: &str, field_info: FieldInfo) -> Self { + Self::new(declaring_class, &field_info.name, &field_info.descriptor, field_info.access_flags) } } diff --git a/jvm-bytecode/src/interpreter.rs b/jvm-bytecode/src/interpreter.rs index 1beb3189..6d5cbd5a 100644 --- a/jvm-bytecode/src/interpreter.rs +++ b/jvm-bytecode/src/interpreter.rs @@ -445,7 +445,7 @@ impl Interpreter { return Err(jvm.exception("java/lang/NullPointerException", "null").await); } - let value = jvm.get_field(&instance.unwrap(), &x.name, &x.descriptor).await?; + let value = jvm.get_field_from_class(&instance.unwrap(), &x.class, &x.name, &x.descriptor).await?; stack_frame.operand_stack.push(Self::to_stack_frame_type(value)); } @@ -921,7 +921,8 @@ impl Interpreter { let value = Self::to_field_type(&x.descriptor, value); - jvm.put_field(instance.as_mut().unwrap(), &x.name, &x.descriptor, value).await?; + jvm.put_field_from_class(instance.as_mut().unwrap(), &x.class, &x.name, &x.descriptor, value) + .await?; } Opcode::Putstatic(x) => { let x = x.as_field_ref(); diff --git a/jvm/src/jvm.rs b/jvm/src/jvm.rs index 5c756333..b17119ee 100644 --- a/jvm/src/jvm.rs +++ b/jvm/src/jvm.rs @@ -265,11 +265,23 @@ impl Jvm { where T: From, { - tracing::trace!("Get field {}.{name}:{descriptor}", instance.class_definition().name()); + self.get_field_from_class(instance, &instance.class_definition().name(), name, descriptor) + .await + } - let field = self.find_field(&*instance.class_definition(), name, descriptor)?; + pub async fn get_field_from_class(&self, instance: &Box, class_name: &str, name: &str, descriptor: &str) -> Result + where + T: From, + { + tracing::trace!("Get field {class_name}.{name}:{descriptor}"); - if let Some(field) = field { + let class = self.resolve_class(class_name).await?; + if let Some((_, field)) = self.resolve_field(&class, name, descriptor) { + if field.access_flags().contains(FieldAccessFlags::STATIC) { + return Err(self + .exception("java/lang/IncompatibleClassChangeError", &format!("{class_name}.{name}:{descriptor}")) + .await); + } let value = instance.get_field(&*field)?; if let JavaValue::Object(Some(instance)) = &value { let thread_id = (self.inner.get_current_thread_id)(); @@ -285,10 +297,7 @@ impl Jvm { Ok(value.into()) } else { Err(self - .exception( - "java/lang/NoSuchFieldError", - &format!("{}.{}:{}", instance.class_definition().name(), name, descriptor), - ) + .exception("java/lang/NoSuchFieldError", &format!("{class_name}.{name}:{descriptor}")) .await) } } @@ -297,18 +306,34 @@ impl Jvm { where T: Into + Debug, { - tracing::trace!("Put field {}.{name}:{descriptor} = {value:?}", instance.class_definition().name()); + self.put_field_from_class(instance, &instance.class_definition().name(), name, descriptor, value) + .await + } - let field = self.find_field(&*instance.class_definition(), name, descriptor)?; + pub async fn put_field_from_class( + &self, + instance: &mut Box, + class_name: &str, + name: &str, + descriptor: &str, + value: T, + ) -> Result<()> + where + T: Into + Debug, + { + tracing::trace!("Put field {class_name}.{name}:{descriptor} = {value:?}"); - if let Some(field) = field { + let class = self.resolve_class(class_name).await?; + if let Some((_, field)) = self.resolve_field(&class, name, descriptor) { + if field.access_flags().contains(FieldAccessFlags::STATIC) { + return Err(self + .exception("java/lang/IncompatibleClassChangeError", &format!("{class_name}.{name}:{descriptor}")) + .await); + } instance.put_field(&*field, value.into()) } else { Err(self - .exception( - "java/lang/NoSuchFieldError", - &format!("{}.{}:{}", instance.class_definition().name(), name, descriptor), - ) + .exception("java/lang/NoSuchFieldError", &format!("{class_name}.{name}:{descriptor}")) .await) } } diff --git a/test-data/Field$Base.class b/test-data/Field$Base.class new file mode 100644 index 0000000000000000000000000000000000000000..c5bc11a98649ebafd2db08f36c4c1893558fb5c2 GIT binary patch literal 507 zcmZ8eO-sX25S*7ZO`1jrS&ew7!&B6#oz z_@l&mwJ3Pm-R#cJ%)Weny?+2WM#F^x(?-FAg`$ApmlN4cW%k&-j`}Jd2^7zgEE$~( zmU`=E?*4>VSK%fv2tmi8p zR#6owt-;{ zW7SSH?#JbkrWWuzS*G$nJDWg17W-@b zIw4LlSHm}murP%k`sFDW!eD8N<(JvsI%9wWqrqsR#8@E*u<^^&nDZ1vlN^70`UioY pEN%gt*qZCsn6<7IzQTTHA)sZnEzq`sZDs>C>@d6RI@rY?oNud6OX&ar literal 0 HcmV?d00001 diff --git a/test-data/Field$Derived.class b/test-data/Field$Derived.class new file mode 100644 index 0000000000000000000000000000000000000000..ff0cff558ede7afd5bf0e9451d459ba392292d6b GIT binary patch literal 472 zcmXX?%TB^j6r5WMZLvrxicfsSg?1quS87ZYLqbAyp>e_P(q2tTElCS}l^YX@i3>l# zk1|eaH)qac?wm9C_wV}$z&Vbp&`>g<+bE+VQ0;{(3XX4Osst)mVH{4c1xhEU&lXHr z2C6nzU<=f8;+;yuxeCaY{*;-37-q~>8+AAW<++SzS+{S(6)=LFpHbFqtfM7hCF(^b zD)vcp2V*&xok+&7orlp_`O`}Qy*mjws}I6h-Ot`eDtVHlh@D!Yc2lh8nL}E5oXiqm z^}>vj`#H;01?+wttE3yrG*zjAeV(^;!4cL?RIzVt?sKu2dy0{>w^Y;RAe>m|lrVX3m*8 z^Ll@tF90JneK;s6xB-eN5vp^;anzl0YHl16N@J6l%Y;zq^|uNh!T)tESsw`Q^c*oE zT$+Se*VB&Ejo!sl@z>{Ty63sEi5(dp^-U9kMUrqjjdhlBrVtW}Rwk(bRX5*`4wO8X r8;Q$%f@NWCL0cI-KzA$q5_1`7$w)=eL4c}YQ<#Gq>hNS;4Gnl-RrV|b literal 0 HcmV?d00001 diff --git a/test-data/Field.class b/test-data/Field.class index c7f2f0fdcabcb0ff1036e2af6beaf2f05e814963..ec3d00bb8330e6641cca3f1a53bf108ae00b7a89 100644 GIT binary patch delta 722 zcmZ8fOK%cU6#g#n8KU~5~USg;gZQ2OwN%E|!-rI`>jAS)AgChknw zxpiHW8koj5@dx;$jNi=|O1mqFJx+>z{=wws6!BYG$dl+&;QjiHBz^^TSpav^LA1l}69*&9eoQNulK z2`IMNF==cuRk(I!42_Is^j>EUnnz}9kPl&7R`{lCwPl#1tYk-4vMX>o{y%?ykWbWu zsQ&G+W*Qw86?hdsxp7srIUlXs>zVepW%T=IUm*BrP;AW|h);Trk45ybhCL2f!3Aj4 z9*Q3U2<#I@sfDy8Pa#eS1P=JhZ;2Hg;t@5eB28C6t!LwiCp$Vv?Byxqd-{ILLE;;( zP^BHL5a|xqh*GoHrpW5E$tm)w@ZBj2dbl)2S#l@HI*3Z{1bG+HR&a3NwUvp^QDKG$ z8$O!md=or$c@k!w5u*R9ZQ?5HT42>TaS@BSggEB7of}x*~!Xv>ff$?3=9m840;>6>=`GgGNnxZz$DA8#-Kh~fLYW+11KlUzzBp446It) z85lPL8H@~?K#~nC$jHFSpv9mKWP_CEGB5!l1B2z{SY``zgjyvA4xlI}P!AUa9|I4A fFas}xBm+N#GJ^nvE`uP01%nXK1RbCnCI(#qM{W^! diff --git a/test-data/Field.txt b/test-data/Field.txt index d162f05d..8fd88c18 100644 --- a/test-data/Field.txt +++ b/test-data/Field.txt @@ -1,3 +1,11 @@ 1 test1 1234 +false +true +31 +42 +parent +child +22 +11 diff --git a/test-data/src/Field.java b/test-data/src/Field.java index d0182ac4..0fcd13d0 100644 --- a/test-data/src/Field.java +++ b/test-data/src/Field.java @@ -1,4 +1,31 @@ class Field { + static class Base { + private boolean active = true; + public int value = 11; + public Object reference = "base"; + + void clear() { + active = false; + } + + boolean baseActive() { + return active; + } + } + + static class Derived extends Base { + private boolean active = true; + public int value = 22; + public Object reference = "derived"; + + boolean derivedActive() { + return active; + } + } + + static class Leaf extends Derived { + } + public int int_field; public String string_field; public long long_field; @@ -15,5 +42,24 @@ public static void main(String[] args) { System.out.println(field.int_field); System.out.println(field.string_field); System.out.println(field.static_field); + + Derived child = new Derived(); + Base parent = child; + parent.clear(); + System.out.println(parent.baseActive()); + System.out.println(child.derivedActive()); + + parent.value = 31; + child.value = 42; + parent.reference = "parent"; + child.reference = "child"; + System.out.println(parent.value); + System.out.println(child.value); + System.out.println(parent.reference); + System.out.println(child.reference); + + Leaf leaf = new Leaf(); + System.out.println(leaf.value); + System.out.println(((Base) leaf).value); } } From 7e13a534712cd9d618fa3bdd70d282ccb85624ca Mon Sep 17 00:00:00 2001 From: Inseok Lee Date: Thu, 24 Sep 2026 09:07:44 +0900 Subject: [PATCH 2/2] Require explicit class names in instance field APIs --- jvm-bytecode/src/interpreter.rs | 5 +- jvm/src/jvm.rs | 29 +- jvm/src/runtime/java_lang_class.rs | 10 +- jvm/src/runtime/java_lang_string.rs | 6 +- jvm/tests/test_garbage_collection.rs | 3 +- .../classes/java/io/buffered_input_stream.rs | 110 ++-- .../classes/java/io/buffered_output_stream.rs | 43 +- .../src/classes/java/io/buffered_reader.rs | 197 ++++--- .../src/classes/java/io/buffered_writer.rs | 81 +-- .../java/io/byte_array_input_stream.rs | 51 +- .../java/io/byte_array_output_stream.rs | 42 +- .../src/classes/java/io/char_array_reader.rs | 68 +-- .../src/classes/java/io/char_array_writer.rs | 60 +- .../src/classes/java/io/data_input_stream.rs | 4 +- .../src/classes/java/io/data_output_stream.rs | 20 +- rustjava-runtime/src/classes/java/io/file.rs | 4 +- .../src/classes/java/io/file_descriptor.rs | 15 +- .../src/classes/java/io/file_input_stream.rs | 11 +- .../src/classes/java/io/file_output_stream.rs | 16 +- .../classes/java/io/filter_input_stream.rs | 21 +- .../classes/java/io/filter_output_stream.rs | 25 +- .../classes/java/io/input_stream_reader.rs | 58 +- .../java/io/interrupted_io_exception.rs | 6 +- .../classes/java/io/output_stream_writer.rs | 43 +- .../src/classes/java/io/print_stream.rs | 74 ++- .../src/classes/java/io/print_writer.rs | 84 +-- .../src/classes/java/io/random_access_file.rs | 19 +- .../src/classes/java/io/reader.rs | 2 +- .../src/classes/java/io/string_reader.rs | 65 ++- .../src/classes/java/io/string_writer.rs | 7 +- .../src/classes/java/io/writer.rs | 2 +- .../java/lang/abstract_string_builder.rs | 30 +- .../src/classes/java/lang/boolean.rs | 6 +- .../src/classes/java/lang/byte.rs | 6 +- .../src/classes/java/lang/character.rs | 4 +- .../src/classes/java/lang/class.rs | 7 +- .../src/classes/java/lang/class_loader.rs | 10 +- .../src/classes/java/lang/double.rs | 6 +- .../src/classes/java/lang/enum.rs | 14 +- .../lang/exception_in_initializer_error.rs | 12 +- .../src/classes/java/lang/float.rs | 8 +- .../src/classes/java/lang/integer.rs | 8 +- .../src/classes/java/lang/long.rs | 16 +- .../src/classes/java/lang/short.rs | 18 +- .../src/classes/java/lang/string.rs | 32 +- .../src/classes/java/lang/string_buffer.rs | 75 +-- .../src/classes/java/lang/string_builder.rs | 4 +- .../src/classes/java/lang/thread.rs | 59 +- .../src/classes/java/lang/throwable.rs | 31 +- .../classes/java/net/jar_url_connection.rs | 10 +- rustjava-runtime/src/classes/java/net/url.rs | 26 +- .../src/classes/java/net/url_class_loader.rs | 5 +- .../src/classes/java/text/date_format.rs | 69 ++- .../src/classes/java/text/decimal_format.rs | 133 ++++- .../src/classes/java/text/field_position.rs | 40 +- .../src/classes/java/text/number_format.rs | 74 ++- .../src/classes/java/text/parse_exception.rs | 5 +- .../src/classes/java/text/parse_position.rs | 28 +- .../classes/java/text/simple_date_format.rs | 24 +- .../src/classes/java/util/abstract_list.rs | 56 +- .../java/util/abstract_list_sub_list.rs | 73 ++- .../src/classes/java/util/array_list.rs | 56 +- .../src/classes/java/util/array_list_itr.rs | 55 +- .../classes/java/util/arrays_array_list.rs | 9 +- .../src/classes/java/util/calendar.rs | 54 +- .../java/util/collections_copies_list.rs | 50 +- .../java/util/collections_singleton_set.rs | 23 +- .../collections_unmodifiable_collection.rs | 41 +- ...ctions_unmodifiable_collection_iterator.rs | 17 +- .../util/collections_unmodifiable_list.rs | 35 +- .../collections_unmodifiable_list_iterator.rs | 33 +- .../java/util/collections_unmodifiable_map.rs | 86 ++- .../collections_unmodifiable_map_entry.rs | 45 +- .../collections_unmodifiable_map_entry_set.rs | 36 +- ...ons_unmodifiable_map_entry_set_iterator.rs | 27 +- .../java/util/collections_unmodifiable_set.rs | 8 +- .../collections_unmodifiable_sorted_map.rs | 33 +- .../collections_unmodifiable_sorted_set.rs | 33 +- .../src/classes/java/util/date.rs | 26 +- .../util/duplicate_format_flags_exception.rs | 10 +- ...mat_flags_conversion_mismatch_exception.rs | 32 +- .../src/classes/java/util/formatter.rs | 33 +- .../classes/java/util/gregorian_calendar.rs | 22 +- .../src/classes/java/util/hash_map.rs | 174 ++++-- .../src/classes/java/util/hash_map_entry.rs | 28 +- .../classes/java/util/hash_map_entry_set.rs | 23 +- .../java/util/hash_map_hash_iterator.rs | 20 +- .../src/classes/java/util/hash_map_key_set.rs | 15 +- .../src/classes/java/util/hash_map_values.rs | 15 +- .../src/classes/java/util/hash_set.rs | 21 +- .../src/classes/java/util/hashtable.rs | 199 ++++--- .../src/classes/java/util/hashtable_entry.rs | 28 +- .../classes/java/util/hashtable_entry_set.rs | 31 +- .../classes/java/util/hashtable_enumerator.rs | 20 +- .../classes/java/util/hashtable_key_set.rs | 15 +- .../src/classes/java/util/hashtable_values.rs | 15 +- .../illegal_format_code_point_exception.rs | 9 +- .../illegal_format_conversion_exception.rs | 26 +- .../util/illegal_format_flags_exception.rs | 10 +- .../illegal_format_precision_exception.rs | 9 +- .../util/illegal_format_width_exception.rs | 7 +- .../src/classes/java/util/jar/attributes.rs | 7 +- .../classes/java/util/jar/jar_file_entries.rs | 17 +- .../src/classes/java/util/jar/manifest.rs | 12 +- .../src/classes/java/util/linked_hash_map.rs | 138 ++++- .../java/util/linked_hash_map_entry.rs | 103 +++- .../java/util/linked_hash_map_key_iterator.rs | 2 +- .../linked_hash_map_linked_hash_iterator.rs | 152 ++++- .../util/linked_hash_map_value_iterator.rs | 3 +- .../src/classes/java/util/linked_list.rs | 222 +++++-- .../classes/java/util/linked_list_entry.rs | 15 +- .../src/classes/java/util/linked_list_itr.rs | 72 ++- .../src/classes/java/util/locale.rs | 61 +- .../src/classes/java/util/logging/handler.rs | 40 +- .../src/classes/java/util/logging/level.rs | 17 +- .../classes/java/util/logging/log_manager.rs | 54 +- .../classes/java/util/logging/log_record.rs | 102 +++- .../src/classes/java/util/logging/logger.rs | 140 +++-- .../java/util/logging/stream_handler.rs | 102 +++- .../util/missing_format_argument_exception.rs | 16 +- .../util/missing_format_width_exception.rs | 12 +- .../src/classes/java/util/properties.rs | 9 +- .../src/classes/java/util/random.rs | 19 +- .../src/classes/java/util/regex/matcher.rs | 154 +++-- .../src/classes/java/util/regex/pattern.rs | 9 +- .../util/regex/pattern_syntax_exception.rs | 39 +- .../src/classes/java/util/simple_time_zone.rs | 10 +- .../src/classes/java/util/string_tokenizer.rs | 56 +- .../src/classes/java/util/time_zone.rs | 6 +- .../src/classes/java/util/timer.rs | 42 +- .../src/classes/java/util/timer_task.rs | 15 +- .../src/classes/java/util/timer_task_queue.rs | 53 +- .../src/classes/java/util/timer_thread.rs | 52 +- .../src/classes/java/util/tree_map.rs | 546 ++++++++++++------ .../src/classes/java/util/tree_map_entry.rs | 28 +- .../classes/java/util/tree_map_entry_set.rs | 13 +- .../java/util/tree_map_key_iterator.rs | 2 +- .../src/classes/java/util/tree_map_key_set.rs | 13 +- .../util/tree_map_private_entry_iterator.rs | 107 +++- .../src/classes/java/util/tree_map_sub_map.rs | 95 +-- .../java/util/tree_map_value_iterator.rs | 2 +- .../src/classes/java/util/tree_map_values.rs | 13 +- .../src/classes/java/util/tree_set.rs | 30 +- .../unknown_format_conversion_exception.rs | 16 +- .../util/unknown_format_flags_exception.rs | 10 +- .../src/classes/java/util/vector.rs | 117 ++-- .../src/classes/java/util/vector_itr.rs | 55 +- .../src/classes/java/util/zip/zip_entry.rs | 18 +- .../src/classes/java/util/zip/zip_file.rs | 4 +- .../classes/java/util/zip/zip_file_entries.rs | 26 +- .../rustjava/lang/rust_jar_class_loader.rs | 13 +- .../org/rustjava/net/file_url_connection.rs | 7 +- .../classes/java/io/test_buffered_reader.rs | 79 +-- .../classes/java/io/test_buffered_streams.rs | 11 +- .../java/io/test_file_reader_writer.rs | 7 +- .../java/io/test_input_stream_reader.rs | 10 +- .../java/io/test_output_stream_close.rs | 108 ++-- .../classes/java/io/test_print_stream.rs | 282 +++++---- .../classes/java/io/test_print_writer.rs | 219 +++---- .../classes/java/io/test_stream_locking.rs | 103 ++-- .../tests/classes/java/lang/test_class.rs | 17 +- .../tests/classes/java/lang/test_object.rs | 13 +- .../tests/classes/java/lang/test_string.rs | 60 +- .../classes/java/lang/test_string_buffer.rs | 8 +- .../tests/classes/java/lang/test_thread.rs | 10 +- .../classes/java/util/jar/test_attributes.rs | 2 +- .../classes/java/util/jar/test_jar_file.rs | 16 +- .../java/util/logging/test_handlers.rs | 7 +- .../classes/java/util/regex/test_matcher.rs | 61 +- .../classes/java/util/test_array_list.rs | 16 +- .../tests/classes/java/util/test_arrays.rs | 44 +- .../java/util/test_collection_contracts.rs | 226 +++++--- .../classes/java/util/test_collections.rs | 309 ++++++---- .../tests/classes/java/util/test_hash_map.rs | 30 +- .../tests/classes/java/util/test_hash_set.rs | 8 +- .../classes/java/util/test_linked_hash_map.rs | 14 +- .../classes/java/util/test_list_views.rs | 76 ++- .../classes/java/util/test_properties.rs | 18 +- .../tests/classes/java/util/test_random.rs | 10 +- .../java/util/test_string_tokenizer.rs | 26 +- .../tests/classes/java/util/test_timer.rs | 147 +++-- .../tests/classes/java/util/test_tree_map.rs | 125 ++-- .../lang/test_rust_jar_class_loader.rs | 2 +- 183 files changed, 5320 insertions(+), 3109 deletions(-) diff --git a/jvm-bytecode/src/interpreter.rs b/jvm-bytecode/src/interpreter.rs index 6d5cbd5a..a8aee23c 100644 --- a/jvm-bytecode/src/interpreter.rs +++ b/jvm-bytecode/src/interpreter.rs @@ -445,7 +445,7 @@ impl Interpreter { return Err(jvm.exception("java/lang/NullPointerException", "null").await); } - let value = jvm.get_field_from_class(&instance.unwrap(), &x.class, &x.name, &x.descriptor).await?; + let value = jvm.get_field(&instance.unwrap(), &x.class, &x.name, &x.descriptor).await?; stack_frame.operand_stack.push(Self::to_stack_frame_type(value)); } @@ -921,8 +921,7 @@ impl Interpreter { let value = Self::to_field_type(&x.descriptor, value); - jvm.put_field_from_class(instance.as_mut().unwrap(), &x.class, &x.name, &x.descriptor, value) - .await?; + jvm.put_field(instance.as_mut().unwrap(), &x.class, &x.name, &x.descriptor, value).await?; } Opcode::Putstatic(x) => { let x = x.as_field_ref(); diff --git a/jvm/src/jvm.rs b/jvm/src/jvm.rs index b17119ee..2403542e 100644 --- a/jvm/src/jvm.rs +++ b/jvm/src/jvm.rs @@ -261,15 +261,7 @@ impl Jvm { } } - pub async fn get_field(&self, instance: &Box, name: &str, descriptor: &str) -> Result - where - T: From, - { - self.get_field_from_class(instance, &instance.class_definition().name(), name, descriptor) - .await - } - - pub async fn get_field_from_class(&self, instance: &Box, class_name: &str, name: &str, descriptor: &str) -> Result + pub async fn get_field(&self, instance: &Box, class_name: &str, name: &str, descriptor: &str) -> Result where T: From, { @@ -302,22 +294,7 @@ impl Jvm { } } - pub async fn put_field(&self, instance: &mut Box, name: &str, descriptor: &str, value: T) -> Result<()> - where - T: Into + Debug, - { - self.put_field_from_class(instance, &instance.class_definition().name(), name, descriptor, value) - .await - } - - pub async fn put_field_from_class( - &self, - instance: &mut Box, - class_name: &str, - name: &str, - descriptor: &str, - value: T, - ) -> Result<()> + pub async fn put_field(&self, instance: &mut Box, class_name: &str, name: &str, descriptor: &str, value: T) -> Result<()> where T: Into + Debug, { @@ -1124,7 +1101,7 @@ impl Jvm { .get_mut(&thread_id) .unwrap() .set_java_thread(java_thread.clone()); - let interrupted: bool = self.get_field(&java_thread, "interrupted", "Z").await?; + let interrupted: bool = self.get_field(&java_thread, "java/lang/Thread", "interrupted", "Z").await?; self.inner.threads.write().get_mut(&thread_id).unwrap().interrupted |= interrupted; Ok(()) diff --git a/jvm/src/runtime/java_lang_class.rs b/jvm/src/runtime/java_lang_class.rs index 2f38e180..b9e3ff6c 100644 --- a/jvm/src/runtime/java_lang_class.rs +++ b/jvm/src/runtime/java_lang_class.rs @@ -12,14 +12,14 @@ impl JavaLangClass { let mut name_bytes = jvm.instantiate_array("B", name.len()).await?; let bytes: Vec = cast_vec(name.as_bytes().to_vec()); jvm.store_array(&mut name_bytes, 0, bytes).await?; - jvm.put_field(&mut java_class, "nameBytes", "[B", name_bytes).await?; + jvm.put_field(&mut java_class, "java/lang/Class", "nameBytes", "[B", name_bytes).await?; Ok(java_class) } #[allow(clippy::borrowed_box)] pub async fn name(jvm: &Jvm, this: &Box) -> Result { - let name_bytes: ClassInstanceRef> = jvm.get_field(this, "nameBytes", "[B").await?; + let name_bytes: ClassInstanceRef> = jvm.get_field(this, "java/lang/Class", "nameBytes", "[B").await?; let len = jvm.array_length(&name_bytes).await?; let name_bytes_vec: Vec = jvm.load_array(&name_bytes, 0, len).await?; match String::from_utf8(cast_vec(name_bytes_vec)) { @@ -49,9 +49,9 @@ impl JavaLangClass { let mut name_bytes = jvm.instantiate_array("B", class_name.len()).await?; let bytes: Vec = cast_vec(class_name.into_owned().into_bytes()); jvm.store_array(&mut name_bytes, 0, bytes).await?; - jvm.put_field(&mut java_class, "nameBytes", "[B", name_bytes).await?; + jvm.put_field(&mut java_class, "java/lang/Class", "nameBytes", "[B", name_bytes).await?; - jvm.put_field(&mut java_class, "classLoader", "Ljava/lang/ClassLoader;", class_loader) + jvm.put_field(&mut java_class, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;", class_loader) .await?; Ok(java_class) @@ -59,6 +59,6 @@ impl JavaLangClass { #[allow(clippy::borrowed_box)] pub async fn class_loader(jvm: &Jvm, this: &Box) -> Result>> { - jvm.get_field(this, "classLoader", "Ljava/lang/ClassLoader;").await + jvm.get_field(this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await } } diff --git a/jvm/src/runtime/java_lang_string.rs b/jvm/src/runtime/java_lang_string.rs index e506324f..4fc8ad04 100644 --- a/jvm/src/runtime/java_lang_string.rs +++ b/jvm/src/runtime/java_lang_string.rs @@ -7,9 +7,9 @@ pub struct JavaLangString; impl JavaLangString { #[allow(clippy::borrowed_box)] pub async fn to_utf16(jvm: &Jvm, this: &Box) -> Result> { - let value = jvm.get_field(this, "value", "[C").await?; - let offset: i32 = jvm.get_field(this, "offset", "I").await?; - let count: i32 = jvm.get_field(this, "count", "I").await?; + let value = jvm.get_field(this, "java/lang/String", "value", "[C").await?; + let offset: i32 = jvm.get_field(this, "java/lang/String", "offset", "I").await?; + let count: i32 = jvm.get_field(this, "java/lang/String", "count", "I").await?; // access flags are not enforced, so bytecode can leave a negative here, which would widen into a huge usize if offset < 0 || count < 0 { diff --git a/jvm/tests/test_garbage_collection.rs b/jvm/tests/test_garbage_collection.rs index c5621c39..6b6651d9 100644 --- a/jvm/tests/test_garbage_collection.rs +++ b/jvm/tests/test_garbage_collection.rs @@ -230,10 +230,11 @@ async fn field_and_method_results_are_local_references() -> JvmResult<()> { assert_eq!(jvm.collect_garbage()?, 0); jvm.push_native_frame(); - let _: ClassInstanceRef> = jvm.get_field(&vector, "elementData", "[Ljava/lang/Object;").await?; + let _: ClassInstanceRef> = jvm.get_field(&vector, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let mut mutable_vector = (*vector).clone(); jvm.put_field( &mut mutable_vector, + "java/util/Vector", "elementData", "[Ljava/lang/Object;", ClassInstanceRef::>::new(None), diff --git a/rustjava-runtime/src/classes/java/io/buffered_input_stream.rs b/rustjava-runtime/src/classes/java/io/buffered_input_stream.rs index 0473cddf..0018613c 100644 --- a/rustjava-runtime/src/classes/java/io/buffered_input_stream.rs +++ b/rustjava-runtime/src/classes/java/io/buffered_input_stream.rs @@ -83,23 +83,23 @@ impl BufferedInputStream { .invoke_special(&this, "java/io/FilterInputStream", "", "(Ljava/io/InputStream;)V", (r#in,)) .await?; let buffer = jvm.instantiate_array("B", size as usize).await?; - jvm.put_field(&mut this, "buf", "[B", buffer).await?; - jvm.put_field(&mut this, "count", "I", 0).await?; - jvm.put_field(&mut this, "pos", "I", 0).await?; - jvm.put_field(&mut this, "markpos", "I", -1).await?; - jvm.put_field(&mut this, "marklimit", "I", 0).await + jvm.put_field(&mut this, "java/io/BufferedInputStream", "buf", "[B", buffer).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "count", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "markpos", "I", -1).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "marklimit", "I", 0).await } async fn fill(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result { - let r#in: ClassInstanceRef = jvm.get_field(this, "in", "Ljava/io/InputStream;").await?; - let mut buffer: ClassInstanceRef> = jvm.get_field(this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let mut buffer: ClassInstanceRef> = jvm.get_field(this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let mut position: i32 = jvm.get_field(this, "pos", "I").await?; - let mut mark_position: i32 = jvm.get_field(this, "markpos", "I").await?; - let mark_limit: i32 = jvm.get_field(this, "marklimit", "I").await?; + let mut position: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "pos", "I").await?; + let mut mark_position: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "markpos", "I").await?; + let mark_limit: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "marklimit", "I").await?; let mut buffer_length = jvm.array_length(&buffer).await? as i32; if mark_position < 0 { @@ -133,13 +133,13 @@ impl BufferedInputStream { .await?; buffer = new_buffer; buffer_length = new_length; - jvm.put_field(this, "buf", "[B", buffer.clone()).await?; + jvm.put_field(this, "java/io/BufferedInputStream", "buf", "[B", buffer.clone()).await?; } } - jvm.put_field(this, "pos", "I", position).await?; - jvm.put_field(this, "markpos", "I", mark_position).await?; - jvm.put_field(this, "count", "I", position).await?; + jvm.put_field(this, "java/io/BufferedInputStream", "pos", "I", position).await?; + jvm.put_field(this, "java/io/BufferedInputStream", "markpos", "I", mark_position).await?; + jvm.put_field(this, "java/io/BufferedInputStream", "count", "I", position).await?; let read: i32 = jvm .invoke_virtual( @@ -151,7 +151,7 @@ impl BufferedInputStream { ) .await?; if read > 0 { - jvm.put_field(this, "count", "I", position + read).await?; + jvm.put_field(this, "java/io/BufferedInputStream", "count", "I", position + read).await?; } Ok(read) } @@ -159,28 +159,28 @@ impl BufferedInputStream { async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.BufferedInputStream::read({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let mut position: i32 = jvm.get_field(&this, "pos", "I").await?; - let mut count: i32 = jvm.get_field(&this, "count", "I").await?; + let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; if position >= count { if Self::fill(jvm, &mut this).await? == -1 { return Ok(-1); } - position = jvm.get_field(&this, "pos", "I").await?; - count = jvm.get_field(&this, "count", "I").await?; + position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; if position >= count { return Ok(-1); } } - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; let value = jvm.load_array::(&buffer, position as usize, 1).await?[0]; - jvm.put_field(&mut this, "pos", "I", position + 1).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + 1).await?; Ok(value as u8 as i32) } @@ -194,8 +194,8 @@ impl BufferedInputStream { ) -> Result { tracing::debug!("java.io.BufferedInputStream::read({this:?}, {target:?}, {offset}, {length})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -212,21 +212,21 @@ impl BufferedInputStream { let mut total = 0; while total < length { - let mut position: i32 = jvm.get_field(&this, "pos", "I").await?; - let mut count: i32 = jvm.get_field(&this, "count", "I").await?; + let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; if position >= count { if Self::fill(jvm, &mut this).await? == -1 { break; } - position = jvm.get_field(&this, "pos", "I").await?; - count = jvm.get_field(&this, "count", "I").await?; + position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; if position >= count { break; } } let copied = (count - position).min(length - total); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; let _: () = jvm .invoke_static( "java/lang/System", @@ -235,7 +235,8 @@ impl BufferedInputStream { (buffer, position, target.clone(), offset + total, copied), ) .await?; - jvm.put_field(&mut this, "pos", "I", position + copied).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + copied) + .await?; total += copied; if total < length { @@ -252,8 +253,8 @@ impl BufferedInputStream { async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, amount: i64) -> Result { tracing::debug!("java.io.BufferedInputStream::skip({this:?}, {amount})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -261,35 +262,36 @@ impl BufferedInputStream { return Ok(0); } - let mut position: i32 = jvm.get_field(&this, "pos", "I").await?; - let mut count: i32 = jvm.get_field(&this, "count", "I").await?; + let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; if position >= count { - let mark_position: i32 = jvm.get_field(&this, "markpos", "I").await?; + let mark_position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "markpos", "I").await?; if mark_position < 0 { return jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (amount,)).await; } if Self::fill(jvm, &mut this).await? == -1 { return Ok(0); } - position = jvm.get_field(&this, "pos", "I").await?; - count = jvm.get_field(&this, "count", "I").await?; + position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; } let skipped = amount.min((count - position) as i64); - jvm.put_field(&mut this, "pos", "I", position + skipped as i32).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + skipped as i32) + .await?; Ok(skipped) } async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.BufferedInputStream::available({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?; let underlying: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?; Ok((count - position).saturating_add(underlying)) } @@ -297,24 +299,25 @@ impl BufferedInputStream { async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, read_limit: i32) -> Result<()> { tracing::debug!("java.io.BufferedInputStream::mark({this:?}, {read_limit})"); - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - jvm.put_field(&mut this, "marklimit", "I", read_limit).await?; - jvm.put_field(&mut this, "markpos", "I", position).await + let position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "marklimit", "I", read_limit) + .await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "markpos", "I", position).await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedInputStream::reset({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?; if r#in.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let mark_position: i32 = jvm.get_field(&this, "markpos", "I").await?; + let mark_position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "markpos", "I").await?; if mark_position < 0 { return Err(jvm.exception("java/io/IOException", "Resetting to invalid mark").await); } - jvm.put_field(&mut this, "pos", "I", mark_position).await + jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", mark_position).await } async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { @@ -325,14 +328,15 @@ impl BufferedInputStream { async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedInputStream::close({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?; if r#in.is_null() { return Ok(()); } let null_input: ClassInstanceRef = None.into(); let null_buffer: ClassInstanceRef> = None.into(); - jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", null_input).await?; - jvm.put_field(&mut this, "buf", "[B", null_buffer).await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;", null_input) + .await?; + jvm.put_field(&mut this, "java/io/BufferedInputStream", "buf", "[B", null_buffer).await?; jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await } } diff --git a/rustjava-runtime/src/classes/java/io/buffered_output_stream.rs b/rustjava-runtime/src/classes/java/io/buffered_output_stream.rs index 59d0dd89..fc48d5b0 100644 --- a/rustjava-runtime/src/classes/java/io/buffered_output_stream.rs +++ b/rustjava-runtime/src/classes/java/io/buffered_output_stream.rs @@ -69,22 +69,24 @@ impl BufferedOutputStream { .invoke_special(&this, "java/io/FilterOutputStream", "", "(Ljava/io/OutputStream;)V", (out,)) .await?; let buffer = jvm.instantiate_array("B", size as usize).await?; - jvm.put_field(&mut this, "buf", "[B", buffer).await?; - jvm.put_field(&mut this, "count", "I", 0).await + jvm.put_field(&mut this, "java/io/BufferedOutputStream", "buf", "[B", buffer).await?; + jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", 0).await } async fn flush_buffer(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let out: ClassInstanceRef = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(this, "buf", "[B").await?; + let out: ClassInstanceRef = jvm + .get_field(this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; + let buffer: ClassInstanceRef> = jvm.get_field(this, "java/io/BufferedOutputStream", "buf", "[B").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/io/BufferedOutputStream", "count", "I").await?; if count > 0 { let _: () = jvm .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (buffer, 0, count)) .await?; - jvm.put_field(this, "count", "I", 0).await?; + jvm.put_field(this, "java/io/BufferedOutputStream", "count", "I", 0).await?; } Ok(()) } @@ -92,19 +94,21 @@ impl BufferedOutputStream { async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { tracing::debug!("java.io.BufferedOutputStream::write({this:?}, {value})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; - let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let out: ClassInstanceRef = jvm + .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; + let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let mut count: i32 = jvm.get_field(&this, "count", "I").await?; + let mut count: i32 = jvm.get_field(&this, "java/io/BufferedOutputStream", "count", "I").await?; if count >= jvm.array_length(&buffer).await? as i32 { Self::flush_buffer(jvm, &mut this).await?; count = 0; - buffer = jvm.get_field(&this, "buf", "[B").await?; + buffer = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?; } jvm.store_array(&mut buffer, count as usize, [value as i8]).await?; - jvm.put_field(&mut this, "count", "I", count + 1).await + jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", count + 1).await } async fn write_bytes( @@ -121,8 +125,10 @@ impl BufferedOutputStream { if offset < 0 || length < 0 || offset > source_length - length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await); } - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; - let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; + let out: ClassInstanceRef = jvm + .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; + let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -138,11 +144,11 @@ impl BufferedOutputStream { .await; } - let mut count: i32 = jvm.get_field(&this, "count", "I").await?; + let mut count: i32 = jvm.get_field(&this, "java/io/BufferedOutputStream", "count", "I").await?; if length > buffer_length - count { Self::flush_buffer(jvm, &mut this).await?; count = 0; - buffer = jvm.get_field(&this, "buf", "[B").await?; + buffer = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?; } let _: () = jvm .invoke_static( @@ -152,14 +158,17 @@ impl BufferedOutputStream { (bytes, offset, buffer, count, length), ) .await?; - jvm.put_field(&mut this, "count", "I", count + length).await + jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", count + length) + .await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedOutputStream::flush({this:?})"); Self::flush_buffer(jvm, &mut this).await?; - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm + .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await } } diff --git a/rustjava-runtime/src/classes/java/io/buffered_reader.rs b/rustjava-runtime/src/classes/java/io/buffered_reader.rs index 45b60374..a98a883d 100644 --- a/rustjava-runtime/src/classes/java/io/buffered_reader.rs +++ b/rustjava-runtime/src/classes/java/io/buffered_reader.rs @@ -88,14 +88,14 @@ impl BufferedReader { .await?; let cb = jvm.instantiate_array("C", size as usize).await?; - jvm.put_field(&mut this, "in", "Ljava/io/Reader;", r#in).await?; - jvm.put_field(&mut this, "cb", "[C", cb).await?; - jvm.put_field(&mut this, "nChars", "I", 0).await?; - jvm.put_field(&mut this, "nextChar", "I", 0).await?; - jvm.put_field(&mut this, "markedChar", "I", UNMARKED).await?; - jvm.put_field(&mut this, "readAheadLimit", "I", 0).await?; - jvm.put_field(&mut this, "skipLF", "Z", false).await?; - jvm.put_field(&mut this, "markedSkipLF", "Z", false).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "in", "Ljava/io/Reader;", r#in).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "cb", "[C", cb).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nChars", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "markedChar", "I", UNMARKED).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "readAheadLimit", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "markedSkipLF", "Z", false).await?; Ok(()) } @@ -119,21 +119,21 @@ impl BufferedReader { } async fn fill(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result { - let r#in: ClassInstanceRef = jvm.get_field(this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } - let mut cb: ClassInstanceRef> = jvm.get_field(this, "cb", "[C").await?; + let mut cb: ClassInstanceRef> = jvm.get_field(this, "java/io/BufferedReader", "cb", "[C").await?; let mut destination = 0; - let marked_char: i32 = jvm.get_field(this, "markedChar", "I").await?; + let marked_char: i32 = jvm.get_field(this, "java/io/BufferedReader", "markedChar", "I").await?; if marked_char >= 0 { - let next_char: i32 = jvm.get_field(this, "nextChar", "I").await?; + let next_char: i32 = jvm.get_field(this, "java/io/BufferedReader", "nextChar", "I").await?; let delta = next_char - marked_char; - let read_ahead_limit: i32 = jvm.get_field(this, "readAheadLimit", "I").await?; + let read_ahead_limit: i32 = jvm.get_field(this, "java/io/BufferedReader", "readAheadLimit", "I").await?; if delta >= read_ahead_limit { - jvm.put_field(this, "markedChar", "I", INVALIDATED).await?; - jvm.put_field(this, "readAheadLimit", "I", 0).await?; + jvm.put_field(this, "java/io/BufferedReader", "markedChar", "I", INVALIDATED).await?; + jvm.put_field(this, "java/io/BufferedReader", "readAheadLimit", "I", 0).await?; } else { let capacity = jvm.array_length(&cb).await?; if read_ahead_limit as usize > capacity { @@ -148,7 +148,7 @@ impl BufferedReader { ) .await?; cb = expanded.into(); - jvm.put_field(this, "cb", "[C", cb.clone()).await?; + jvm.put_field(this, "java/io/BufferedReader", "cb", "[C", cb.clone()).await?; } else if delta > 0 { let _: () = jvm .invoke_static( @@ -160,13 +160,13 @@ impl BufferedReader { .await?; } - jvm.put_field(this, "markedChar", "I", 0).await?; + jvm.put_field(this, "java/io/BufferedReader", "markedChar", "I", 0).await?; destination = delta; } } - jvm.put_field(this, "nextChar", "I", destination).await?; - jvm.put_field(this, "nChars", "I", destination).await?; + jvm.put_field(this, "java/io/BufferedReader", "nextChar", "I", destination).await?; + jvm.put_field(this, "java/io/BufferedReader", "nChars", "I", destination).await?; let capacity = jvm.array_length(&cb).await? as i32; let mut read; @@ -185,52 +185,52 @@ impl BufferedReader { } } if read > 0 { - jvm.put_field(this, "nChars", "I", destination + read).await?; - jvm.put_field(this, "nextChar", "I", destination).await?; + jvm.put_field(this, "java/io/BufferedReader", "nChars", "I", destination + read).await?; + jvm.put_field(this, "java/io/BufferedReader", "nextChar", "I", destination).await?; } Ok(read) } async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await } async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.BufferedReader::read({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } loop { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let mut n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; if next_char >= n_chars { if Self::fill(jvm, &mut this).await? <= 0 { return Ok(-1); } - next_char = jvm.get_field(&this, "nextChar", "I").await?; - n_chars = jvm.get_field(&this, "nChars", "I").await?; + next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; } - if jvm.get_field::(&this, "skipLF", "Z").await? { - jvm.put_field(&mut this, "skipLF", "Z", false).await?; - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + if jvm.get_field::(&this, "java/io/BufferedReader", "skipLF", "Z").await? { + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; if jvm.load_array::(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar { next_char += 1; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?; if next_char >= n_chars { continue; } } } - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; let value = jvm.load_array::(&cb, next_char as usize, 1).await?[0]; - jvm.put_field(&mut this, "nextChar", "I", next_char + 1).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + 1).await?; return Ok(value as i32); } } @@ -243,7 +243,7 @@ impl BufferedReader { offset: i32, length: i32, ) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await } @@ -256,7 +256,7 @@ impl BufferedReader { ) -> Result { tracing::debug!("java.io.BufferedReader::read({this:?}, {target:?}, {offset}, {length})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } @@ -274,8 +274,8 @@ impl BufferedReader { let mut total = 0; while total < length { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let mut n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; if next_char >= n_chars { if total > 0 && !jvm.invoke_virtual::<_, bool>(&r#in, "java/io/Reader", "ready", "()Z", ()).await? { break; @@ -283,16 +283,16 @@ impl BufferedReader { if Self::fill(jvm, &mut this).await? <= 0 { break; } - next_char = jvm.get_field(&this, "nextChar", "I").await?; - n_chars = jvm.get_field(&this, "nChars", "I").await?; + next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; } - if jvm.get_field::(&this, "skipLF", "Z").await? { - jvm.put_field(&mut this, "skipLF", "Z", false).await?; - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + if jvm.get_field::(&this, "java/io/BufferedReader", "skipLF", "Z").await? { + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; if jvm.load_array::(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar { next_char += 1; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?; if next_char >= n_chars { continue; } @@ -300,7 +300,7 @@ impl BufferedReader { } let count = min(length - total, n_chars - next_char); - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; let _: () = jvm .invoke_static( "java/lang/System", @@ -310,32 +310,33 @@ impl BufferedReader { ) .await?; total += count; - jvm.put_field(&mut this, "nextChar", "I", next_char + count).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + count) + .await?; } if total == 0 { Ok(-1) } else { Ok(total) } } async fn read_line(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_line_locked(jvm, this)).await } async fn read_line_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.BufferedReader::readLine({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } - let mut omit_lf: bool = jvm.get_field(&this, "skipLF", "Z").await?; - jvm.put_field(&mut this, "skipLF", "Z", false).await?; + let mut omit_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "skipLF", "Z").await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; let mut line = Vec::new(); loop { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let mut n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; if next_char >= n_chars { if Self::fill(jvm, &mut this).await? <= 0 { if line.is_empty() { @@ -344,16 +345,16 @@ impl BufferedReader { return Ok(JavaLangString::from_utf16(jvm, line).await?.into()); } - next_char = jvm.get_field(&this, "nextChar", "I").await?; - n_chars = jvm.get_field(&this, "nChars", "I").await?; + next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; } - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; if omit_lf { omit_lf = false; if jvm.load_array::(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar { next_char += 1; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?; if next_char >= n_chars { continue; } @@ -364,28 +365,29 @@ impl BufferedReader { if let Some(index) = buffered.iter().position(|value| *value == '\n' as JavaChar || *value == '\r' as JavaChar) { line.extend_from_slice(&buffered[..index]); let terminator = buffered[index]; - jvm.put_field(&mut this, "nextChar", "I", next_char + index as i32 + 1).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + index as i32 + 1) + .await?; if terminator == '\r' as JavaChar { - jvm.put_field(&mut this, "skipLF", "Z", true).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", true).await?; } return Ok(JavaLangString::from_utf16(jvm, line).await?.into()); } line.extend(buffered); - jvm.put_field(&mut this, "nextChar", "I", n_chars).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", n_chars).await?; } } async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, count: i64) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, count)).await } async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef, count: i64) -> Result { tracing::debug!("java.io.BufferedReader::skip({this:?}, {count})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } @@ -395,22 +397,22 @@ impl BufferedReader { let mut remaining = count; while remaining > 0 { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let mut n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; if next_char >= n_chars { if Self::fill(jvm, &mut this).await? <= 0 { break; } - next_char = jvm.get_field(&this, "nextChar", "I").await?; - n_chars = jvm.get_field(&this, "nChars", "I").await?; + next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; } - if jvm.get_field::(&this, "skipLF", "Z").await? { - jvm.put_field(&mut this, "skipLF", "Z", false).await?; - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + if jvm.get_field::(&this, "java/io/BufferedReader", "skipLF", "Z").await? { + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; if jvm.load_array::(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar { next_char += 1; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?; if next_char >= n_chars { continue; } @@ -419,41 +421,42 @@ impl BufferedReader { let skipped = min(remaining, (n_chars - next_char) as i64); remaining -= skipped; - jvm.put_field(&mut this, "nextChar", "I", next_char + skipped as i32).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + skipped as i32) + .await?; } Ok(count - remaining) } async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await } async fn ready_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.BufferedReader::ready({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let mut n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; - if jvm.get_field::(&this, "skipLF", "Z").await? { + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; + if jvm.get_field::(&this, "java/io/BufferedReader", "skipLF", "Z").await? { if next_char >= n_chars && jvm.invoke_virtual::<_, bool>(&r#in, "java/io/Reader", "ready", "()Z", ()).await? { let _ = Self::fill(jvm, &mut this).await?; - next_char = jvm.get_field(&this, "nextChar", "I").await?; - n_chars = jvm.get_field(&this, "nChars", "I").await?; + next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?; } if next_char < n_chars { - let cb: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let cb: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?; if jvm.load_array::(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar { next_char += 1; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?; } - jvm.put_field(&mut this, "skipLF", "Z", false).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?; } } @@ -469,14 +472,14 @@ impl BufferedReader { } async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, read_ahead_limit: i32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this, read_ahead_limit)).await } async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef, read_ahead_limit: i32) -> Result<()> { tracing::debug!("java.io.BufferedReader::mark({this:?}, {read_ahead_limit})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } @@ -484,28 +487,29 @@ impl BufferedReader { return Err(jvm.exception("java/lang/IllegalArgumentException", "read-ahead limit is negative").await); } - let next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; - let skip_lf: bool = jvm.get_field(&this, "skipLF", "Z").await?; - jvm.put_field(&mut this, "readAheadLimit", "I", read_ahead_limit).await?; - jvm.put_field(&mut this, "markedChar", "I", next_char).await?; - jvm.put_field(&mut this, "markedSkipLF", "Z", skip_lf).await?; + let next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?; + let skip_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "skipLF", "Z").await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "readAheadLimit", "I", read_ahead_limit) + .await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "markedChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "markedSkipLF", "Z", skip_lf).await?; Ok(()) } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await } async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedReader::reset({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Err(jvm.exception("java/io/IOException", "stream is closed").await); } - let marked_char: i32 = jvm.get_field(&this, "markedChar", "I").await?; + let marked_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "markedChar", "I").await?; if marked_char < 0 { let message = if marked_char == INVALIDATED { "mark invalid" @@ -515,30 +519,31 @@ impl BufferedReader { return Err(jvm.exception("java/io/IOException", message).await); } - let marked_skip_lf: bool = jvm.get_field(&this, "markedSkipLF", "Z").await?; - jvm.put_field(&mut this, "nextChar", "I", marked_char).await?; - jvm.put_field(&mut this, "skipLF", "Z", marked_skip_lf).await?; + let marked_skip_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "markedSkipLF", "Z").await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", marked_char).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", marked_skip_lf).await?; Ok(()) } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await } async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedReader::close({this:?})"); - let r#in: ClassInstanceRef = jvm.get_field(&this, "in", "Ljava/io/Reader;").await?; + let r#in: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?; if r#in.is_null() { return Ok(()); } let result = jvm.invoke_virtual(&r#in, "java/io/Reader", "close", "()V", ()).await; let closed: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "in", "Ljava/io/Reader;", closed).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "in", "Ljava/io/Reader;", closed) + .await?; let released: ClassInstanceRef> = None.into(); - jvm.put_field(&mut this, "cb", "[C", released).await?; + jvm.put_field(&mut this, "java/io/BufferedReader", "cb", "[C", released).await?; result } } diff --git a/rustjava-runtime/src/classes/java/io/buffered_writer.rs b/rustjava-runtime/src/classes/java/io/buffered_writer.rs index 46c5f0e3..b46b77c1 100644 --- a/rustjava-runtime/src/classes/java/io/buffered_writer.rs +++ b/rustjava-runtime/src/classes/java/io/buffered_writer.rs @@ -86,11 +86,12 @@ impl BufferedWriter { line_separator = JavaLangString::from_rust_string(jvm, "\n").await?.into(); } - jvm.put_field(&mut this, "out", "Ljava/io/Writer;", out).await?; - jvm.put_field(&mut this, "cb", "[C", buffer).await?; - jvm.put_field(&mut this, "nChars", "I", size).await?; - jvm.put_field(&mut this, "nextChar", "I", 0).await?; - jvm.put_field(&mut this, "lineSeparator", "Ljava/lang/String;", line_separator).await + jvm.put_field(&mut this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;", out).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "cb", "[C", buffer).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "nChars", "I", size).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "nextChar", "I", 0).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "lineSeparator", "Ljava/lang/String;", line_separator) + .await } async fn with_lock(jvm: &Jvm, lock: &ClassInstanceRef, operation: F) -> Result @@ -113,43 +114,43 @@ impl BufferedWriter { } async fn flush_buffer(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let out: ClassInstanceRef = jvm.get_field(this, "out", "Ljava/io/Writer;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(this, "cb", "[C").await?; + let out: ClassInstanceRef = jvm.get_field(this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(this, "java/io/BufferedWriter", "cb", "[C").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let next_char: i32 = jvm.get_field(this, "nextChar", "I").await?; + let next_char: i32 = jvm.get_field(this, "java/io/BufferedWriter", "nextChar", "I").await?; if next_char > 0 { let _: () = jvm .invoke_virtual(&out, "java/io/Writer", "write", "([CII)V", (buffer, 0, next_char)) .await?; - jvm.put_field(this, "nextChar", "I", 0).await?; + jvm.put_field(this, "java/io/BufferedWriter", "nextChar", "I", 0).await?; } Ok(()) } async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: i32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_char_locked(jvm, this, value)).await } async fn write_char_locked(jvm: &Jvm, mut this: ClassInstanceRef, value: i32) -> Result<()> { tracing::debug!("java.io.BufferedWriter::write({this:?}, {value})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; - let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; + let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; + let n_chars: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nChars", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nextChar", "I").await?; if next_char >= n_chars { Self::flush_buffer(jvm, &mut this).await?; next_char = 0; - buffer = jvm.get_field(&this, "cb", "[C").await?; + buffer = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; } jvm.store_array(&mut buffer, next_char as usize, [value as JavaChar]).await?; - jvm.put_field(&mut this, "nextChar", "I", next_char + 1).await + jvm.put_field(&mut this, "java/io/BufferedWriter", "nextChar", "I", next_char + 1).await } async fn write_chars( @@ -160,7 +161,7 @@ impl BufferedWriter { offset: i32, length: i32, ) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_chars_locked(jvm, this, chars, offset, length)).await } @@ -173,8 +174,8 @@ impl BufferedWriter { ) -> Result<()> { tracing::debug!("java.io.BufferedWriter::write({this:?}, {chars:?}, {offset}, {length})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -188,7 +189,7 @@ impl BufferedWriter { if length == 0 { return Ok(()); } - let n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let n_chars: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nChars", "I").await?; if length >= n_chars { Self::flush_buffer(jvm, &mut this).await?; return jvm @@ -199,9 +200,9 @@ impl BufferedWriter { let mut source_position = offset; let end = offset + length; while source_position < end { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nextChar", "I").await?; let copied = (n_chars - next_char).min(end - source_position); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; let _: () = jvm .invoke_static( "java/lang/System", @@ -212,7 +213,7 @@ impl BufferedWriter { .await?; source_position += copied; next_char += copied; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "nextChar", "I", next_char).await?; if next_char >= n_chars { Self::flush_buffer(jvm, &mut this).await?; } @@ -228,7 +229,7 @@ impl BufferedWriter { offset: i32, length: i32, ) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_string_locked(jvm, this, value, offset, length)).await } @@ -241,8 +242,8 @@ impl BufferedWriter { ) -> Result<()> { tracing::debug!("java.io.BufferedWriter::write({this:?}, {value:?}, {offset}, {length})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; if out.is_null() || buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -253,13 +254,13 @@ impl BufferedWriter { if offset < 0 || length < 0 || offset > string_length - length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await); } - let n_chars: i32 = jvm.get_field(&this, "nChars", "I").await?; + let n_chars: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nChars", "I").await?; let mut source_position = offset; let end = offset + length; while source_position < end { - let mut next_char: i32 = jvm.get_field(&this, "nextChar", "I").await?; + let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedWriter", "nextChar", "I").await?; let copied = (n_chars - next_char).min(end - source_position); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "cb", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/BufferedWriter", "cb", "[C").await?; let _: () = jvm .invoke_virtual( &value, @@ -271,7 +272,7 @@ impl BufferedWriter { .await?; source_position += copied; next_char += copied; - jvm.put_field(&mut this, "nextChar", "I", next_char).await?; + jvm.put_field(&mut this, "java/io/BufferedWriter", "nextChar", "I", next_char).await?; if next_char >= n_chars { Self::flush_buffer(jvm, &mut this).await?; } @@ -280,20 +281,22 @@ impl BufferedWriter { } async fn new_line(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::new_line_locked(jvm, this)).await } async fn new_line_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedWriter::newLine({this:?})"); - let line_separator: ClassInstanceRef = jvm.get_field(&this, "lineSeparator", "Ljava/lang/String;").await?; + let line_separator: ClassInstanceRef = jvm + .get_field(&this, "java/io/BufferedWriter", "lineSeparator", "Ljava/lang/String;") + .await?; let length: i32 = jvm.invoke_virtual(&line_separator, "java/lang/String", "length", "()I", ()).await?; Self::write_string_locked(jvm, this, line_separator, 0, length).await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::flush_locked(jvm, this)).await } @@ -301,19 +304,19 @@ impl BufferedWriter { tracing::debug!("java.io.BufferedWriter::flush({this:?})"); Self::flush_buffer(jvm, &mut this).await?; - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; jvm.invoke_virtual(&out, "java/io/Writer", "flush", "()V", ()).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await } async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.BufferedWriter::close({this:?})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { return Ok(()); } @@ -321,8 +324,10 @@ impl BufferedWriter { let close_result: Result<()> = jvm.invoke_virtual(&out, "java/io/Writer", "close", "()V", ()).await; let null_writer: ClassInstanceRef = None.into(); let null_buffer: ClassInstanceRef> = None.into(); - let clear_out_result = jvm.put_field(&mut this, "out", "Ljava/io/Writer;", null_writer).await; - let clear_buffer_result = jvm.put_field(&mut this, "cb", "[C", null_buffer).await; + let clear_out_result = jvm + .put_field(&mut this, "java/io/BufferedWriter", "out", "Ljava/io/Writer;", null_writer) + .await; + let clear_buffer_result = jvm.put_field(&mut this, "java/io/BufferedWriter", "cb", "[C", null_buffer).await; flush_result?; close_result?; diff --git a/rustjava-runtime/src/classes/java/io/byte_array_input_stream.rs b/rustjava-runtime/src/classes/java/io/byte_array_input_stream.rs index b06ee4f4..6d3bf23a 100644 --- a/rustjava-runtime/src/classes/java/io/byte_array_input_stream.rs +++ b/rustjava-runtime/src/classes/java/io/byte_array_input_stream.rs @@ -82,10 +82,17 @@ impl ByteArrayInputStream { let _: () = jvm.invoke_special(&this, "java/io/InputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "buf", "[B", data).await?; - jvm.put_field(&mut this, "pos", "I", offset).await?; - jvm.put_field(&mut this, "count", "I", (offset + length).min(data_length)).await?; - jvm.put_field(&mut this, "mark", "I", offset).await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "buf", "[B", data).await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", offset).await?; + jvm.put_field( + &mut this, + "java/io/ByteArrayInputStream", + "count", + "I", + (offset + length).min(data_length), + ) + .await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", offset).await?; Ok(()) } @@ -93,8 +100,8 @@ impl ByteArrayInputStream { async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.ByteArrayInputStream::available({this:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let pos: i32 = jvm.get_field(&this, "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?; + let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?; Ok((count - pos) as _) } @@ -112,9 +119,9 @@ impl ByteArrayInputStream { if b.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await); } - let buf: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let pos: i32 = jvm.get_field(&this, "pos", "I").await?; + let buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?; + let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?; let target_length = jvm.array_length(&b).await? as i32; if off < 0 || len < 0 || off > target_length - len { @@ -139,7 +146,8 @@ impl ByteArrayInputStream { ) .await?; - jvm.put_field(&mut this, "pos", "I", pos + len_to_read).await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_read) + .await?; Ok(len_to_read) } @@ -147,9 +155,9 @@ impl ByteArrayInputStream { async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})"); - let buf = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let pos: i32 = jvm.get_field(&this, "pos", "I").await?; + let buf = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?; + let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?; if pos >= count { return Ok(-1); @@ -157,7 +165,7 @@ impl ByteArrayInputStream { let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0]; - jvm.put_field(&mut this, "pos", "I", pos + 1).await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + 1).await?; Ok(result as u8 as _) } @@ -171,13 +179,14 @@ impl ByteArrayInputStream { async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, n: i64) -> Result { tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let pos: i32 = jvm.get_field(&this, "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?; + let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?; let available = (count - pos) as i64; let len_to_skip = n.max(0).min(available); - jvm.put_field(&mut this, "pos", "I", pos + len_to_skip as i32).await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_skip as i32) + .await?; Ok(len_to_skip) } @@ -185,8 +194,8 @@ impl ByteArrayInputStream { async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, readlimit: i32) -> Result<()> { tracing::debug!("java.io.ByteArrayInputStream::mark({this:?}, {readlimit:?})"); - let pos: i32 = jvm.get_field(&this, "pos", "I").await?; - jvm.put_field(&mut this, "mark", "I", pos).await?; + let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", pos).await?; Ok(()) } @@ -194,8 +203,8 @@ impl ByteArrayInputStream { async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.ByteArrayInputStream::reset({this:?})"); - let mark: i32 = jvm.get_field(&this, "mark", "I").await?; - jvm.put_field(&mut this, "pos", "I", mark).await?; + let mark: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "mark", "I").await?; + jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", mark).await?; Ok(()) } diff --git a/rustjava-runtime/src/classes/java/io/byte_array_output_stream.rs b/rustjava-runtime/src/classes/java/io/byte_array_output_stream.rs index 6bd99c3a..c8409b45 100644 --- a/rustjava-runtime/src/classes/java/io/byte_array_output_stream.rs +++ b/rustjava-runtime/src/classes/java/io/byte_array_output_stream.rs @@ -85,8 +85,8 @@ impl ByteArrayOutputStream { let array = jvm.instantiate_array("B", size as usize).await?; - jvm.put_field(&mut this, "buf", "[B", array).await?; - jvm.put_field(&mut this, "count", "I", 0).await?; + jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "buf", "[B", array).await?; + jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", 0).await?; Ok(()) } @@ -109,24 +109,24 @@ impl ByteArrayOutputStream { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await); } - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; Self::ensure_capacity(jvm, &mut this, (count + len) as usize).await?; - let mut buf = jvm.get_field(&this, "buf", "[B").await?; + let mut buf = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; let values: Vec = jvm.load_array(&bytes, off as usize, len as usize).await?; jvm.store_array(&mut buf, count as usize, values).await?; - jvm.put_field(&mut this, "count", "I", count + len).await + jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", count + len).await } async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, b: i32) -> Result<()> { tracing::debug!("java.io.ByteArrayOutputStream::write({this:?}, {b:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; Self::ensure_capacity(jvm, &mut this, (count + 1) as _).await?; - let mut buf = jvm.get_field(&this, "buf", "[B").await?; + let mut buf = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; jvm.store_array(&mut buf, count as _, vec![b as i8]).await?; - jvm.put_field(&mut this, "count", "I", count + 1).await?; + jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", count + 1).await?; Ok(()) } @@ -138,8 +138,8 @@ impl ByteArrayOutputStream { return Err(jvm.exception("java/lang/NullPointerException", "output is null").await); } - let buf: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (buf, 0, count)) .await } @@ -147,8 +147,8 @@ impl ByteArrayOutputStream { async fn to_byte_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { tracing::debug!("java.io.ByteArrayOutputStream::to_byte_array({this:?})"); - let buf: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; let dest = jvm.instantiate_array("B", count as _).await?; let _: () = jvm @@ -166,15 +166,15 @@ impl ByteArrayOutputStream { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.ByteArrayOutputStream::size({this:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; Ok(count) } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.ByteArrayOutputStream::toString({this:?})"); - let buf: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; let bytes = jvm.instantiate_array("B", count as usize).await?; let _: () = jvm .invoke_static( @@ -199,8 +199,8 @@ impl ByteArrayOutputStream { return Err(jvm.exception("java/lang/NullPointerException", "encoding is null").await); } - let buf: ClassInstanceRef> = jvm.get_field(&this, "buf", "[B").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; + let count: i32 = jvm.get_field(&this, "java/io/ByteArrayOutputStream", "count", "I").await?; Ok(jvm .new_class("java/lang/String", "([BIILjava/lang/String;)V", (buf, 0, count, encoding)) .await? @@ -210,7 +210,7 @@ impl ByteArrayOutputStream { async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.ByteArrayOutputStream::reset({this:?})"); - jvm.put_field(&mut this, "count", "I", 0).await?; + jvm.put_field(&mut this, "java/io/ByteArrayOutputStream", "count", "I", 0).await?; Ok(()) } @@ -222,13 +222,13 @@ impl ByteArrayOutputStream { } async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef, capacity: usize) -> Result<()> { - let old_buf = jvm.get_field(this, "buf", "[B").await?; + let old_buf = jvm.get_field(this, "java/io/ByteArrayOutputStream", "buf", "[B").await?; let current_capacity = jvm.array_length(&old_buf).await?; if current_capacity < capacity { let new_capacity = current_capacity.saturating_mul(2).max(capacity); let new_buf = jvm.instantiate_array("B", new_capacity).await?; - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/io/ByteArrayOutputStream", "count", "I").await?; let _: () = jvm .invoke_static( @@ -239,7 +239,7 @@ impl ByteArrayOutputStream { ) .await?; - jvm.put_field(this, "buf", "[B", new_buf.clone()).await?; + jvm.put_field(this, "java/io/ByteArrayOutputStream", "buf", "[B", new_buf.clone()).await?; } Ok(()) diff --git a/rustjava-runtime/src/classes/java/io/char_array_reader.rs b/rustjava-runtime/src/classes/java/io/char_array_reader.rs index 123b7242..e6f8421c 100644 --- a/rustjava-runtime/src/classes/java/io/char_array_reader.rs +++ b/rustjava-runtime/src/classes/java/io/char_array_reader.rs @@ -70,10 +70,11 @@ impl CharArrayReader { } let _: () = jvm.invoke_special(&this, "java/io/Reader", "", "()V", ()).await?; - jvm.put_field(&mut this, "buf", "[C", buffer).await?; - jvm.put_field(&mut this, "pos", "I", offset).await?; - jvm.put_field(&mut this, "markedPos", "I", offset).await?; - jvm.put_field(&mut this, "count", "I", end.min(buffer_length as i64) as i32).await + jvm.put_field(&mut this, "java/io/CharArrayReader", "buf", "[C", buffer).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "pos", "I", offset).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "markedPos", "I", offset).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "count", "I", end.min(buffer_length as i64) as i32) + .await } async fn with_lock(jvm: &Jvm, lock: &ClassInstanceRef, operation: F) -> Result @@ -96,24 +97,24 @@ impl CharArrayReader { } async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await } async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.CharArrayReader::read({this:?})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "count", "I").await?; if position >= count { return Ok(-1); } let value = jvm.load_array::(&buffer, position as usize, 1).await?[0]; - jvm.put_field(&mut this, "pos", "I", position + 1).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "pos", "I", position + 1).await?; Ok(value as i32) } @@ -125,7 +126,7 @@ impl CharArrayReader { offset: i32, length: i32, ) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await } @@ -138,7 +139,7 @@ impl CharArrayReader { ) -> Result { tracing::debug!("java.io.CharArrayReader::read({this:?}, {target:?}, {offset}, {length})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -152,8 +153,8 @@ impl CharArrayReader { if length == 0 { return Ok(0); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "count", "I").await?; if position >= count { return Ok(-1); } @@ -166,46 +167,47 @@ impl CharArrayReader { (buffer, position, target, offset, copied), ) .await?; - jvm.put_field(&mut this, "pos", "I", position + copied).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "pos", "I", position + copied).await?; Ok(copied) } async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, amount: i64) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, amount)).await } async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef, amount: i64) -> Result { tracing::debug!("java.io.CharArrayReader::skip({this:?}, {amount})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } if amount <= 0 { return Ok(0); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "count", "I").await?; let skipped = amount.min((count - position) as i64); - jvm.put_field(&mut this, "pos", "I", position + skipped as i32).await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "pos", "I", position + skipped as i32) + .await?; Ok(skipped) } async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await } async fn ready_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.CharArrayReader::ready({this:?})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "pos", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "count", "I").await?; Ok(count - position > 0) } @@ -215,39 +217,39 @@ impl CharArrayReader { } async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, read_ahead_limit: i32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this, read_ahead_limit)).await } async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef, read_ahead_limit: i32) -> Result<()> { tracing::debug!("java.io.CharArrayReader::mark({this:?}, {read_ahead_limit})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let position: i32 = jvm.get_field(&this, "pos", "I").await?; - jvm.put_field(&mut this, "markedPos", "I", position).await + let position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "pos", "I").await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "markedPos", "I", position).await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await } async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.CharArrayReader::reset({this:?})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayReader", "buf", "[C").await?; if buffer.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let marked_position: i32 = jvm.get_field(&this, "markedPos", "I").await?; - jvm.put_field(&mut this, "pos", "I", marked_position).await + let marked_position: i32 = jvm.get_field(&this, "java/io/CharArrayReader", "markedPos", "I").await?; + jvm.put_field(&mut this, "java/io/CharArrayReader", "pos", "I", marked_position).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await } @@ -255,6 +257,6 @@ impl CharArrayReader { tracing::debug!("java.io.CharArrayReader::close({this:?})"); let null_buffer: ClassInstanceRef> = None.into(); - jvm.put_field(&mut this, "buf", "[C", null_buffer).await + jvm.put_field(&mut this, "java/io/CharArrayReader", "buf", "[C", null_buffer).await } } diff --git a/rustjava-runtime/src/classes/java/io/char_array_writer.rs b/rustjava-runtime/src/classes/java/io/char_array_writer.rs index 929ac455..21ec1c71 100644 --- a/rustjava-runtime/src/classes/java/io/char_array_writer.rs +++ b/rustjava-runtime/src/classes/java/io/char_array_writer.rs @@ -61,8 +61,8 @@ impl CharArrayWriter { } let _: () = jvm.invoke_special(&this, "java/io/Writer", "", "()V", ()).await?; let buffer = jvm.instantiate_array("C", size as usize).await?; - jvm.put_field(&mut this, "buf", "[C", buffer).await?; - jvm.put_field(&mut this, "count", "I", 0).await + jvm.put_field(&mut this, "java/io/CharArrayWriter", "buf", "[C", buffer).await?; + jvm.put_field(&mut this, "java/io/CharArrayWriter", "count", "I", 0).await } async fn with_lock(jvm: &Jvm, lock: &ClassInstanceRef, operation: F) -> Result @@ -85,12 +85,12 @@ impl CharArrayWriter { } async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef, minimum: i32) -> Result<()> { - let buffer: ClassInstanceRef> = jvm.get_field(this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(this, "java/io/CharArrayWriter", "buf", "[C").await?; let current = jvm.array_length(&buffer).await? as i32; if minimum > current { let new_length = current.saturating_mul(2).max(minimum).max(1); let new_buffer = jvm.instantiate_array("C", new_length as usize).await?; - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/io/CharArrayWriter", "count", "I").await?; let _: () = jvm .invoke_static( "java/lang/System", @@ -99,24 +99,24 @@ impl CharArrayWriter { (buffer, 0, new_buffer.clone(), 0, count), ) .await?; - jvm.put_field(this, "buf", "[C", new_buffer).await?; + jvm.put_field(this, "java/io/CharArrayWriter", "buf", "[C", new_buffer).await?; } Ok(()) } async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: i32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_char_locked(jvm, this, value)).await } async fn write_char_locked(jvm: &Jvm, mut this: ClassInstanceRef, value: i32) -> Result<()> { tracing::debug!("java.io.CharArrayWriter::write({this:?}, {value})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; Self::ensure_capacity(jvm, &mut this, count + 1).await?; - let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let mut buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; jvm.store_array(&mut buffer, count as usize, [value as JavaChar]).await?; - jvm.put_field(&mut this, "count", "I", count + 1).await + jvm.put_field(&mut this, "java/io/CharArrayWriter", "count", "I", count + 1).await } async fn write_chars( @@ -127,7 +127,7 @@ impl CharArrayWriter { offset: i32, length: i32, ) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_chars_locked(jvm, this, chars, offset, length)).await } @@ -147,9 +147,9 @@ impl CharArrayWriter { if offset < 0 || length < 0 || offset > source_length - length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await); } - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; Self::ensure_capacity(jvm, &mut this, count + length).await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; let _: () = jvm .invoke_static( "java/lang/System", @@ -158,7 +158,7 @@ impl CharArrayWriter { (chars, offset, buffer, count, length), ) .await?; - jvm.put_field(&mut this, "count", "I", count + length).await + jvm.put_field(&mut this, "java/io/CharArrayWriter", "count", "I", count + length).await } async fn write_string( @@ -169,7 +169,7 @@ impl CharArrayWriter { offset: i32, length: i32, ) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_string_locked(jvm, this, value, offset, length)).await } @@ -189,9 +189,9 @@ impl CharArrayWriter { if offset < 0 || length < 0 || offset > source_length - length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await); } - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; Self::ensure_capacity(jvm, &mut this, count + length).await?; - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; let _: () = jvm .invoke_virtual( &value, @@ -201,11 +201,11 @@ impl CharArrayWriter { (offset, offset + length, buffer, count), ) .await?; - jvm.put_field(&mut this, "count", "I", count + length).await + jvm.put_field(&mut this, "java/io/CharArrayWriter", "count", "I", count + length).await } async fn write_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, out: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::write_to_locked(jvm, this, out)).await } @@ -215,31 +215,31 @@ impl CharArrayWriter { if out.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "writer is null").await); } - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; jvm.invoke_virtual(&out, "java/io/Writer", "write", "([CII)V", (buffer, 0, count)).await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await } async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.CharArrayWriter::reset({this:?})"); - jvm.put_field(&mut this, "count", "I", 0).await + jvm.put_field(&mut this, "java/io/CharArrayWriter", "count", "I", 0).await } async fn to_char_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::to_char_array_locked(jvm, this)).await } async fn to_char_array_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result>> { tracing::debug!("java.io.CharArrayWriter::toCharArray({this:?})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; let copy = jvm.instantiate_array("C", count as usize).await?; let _: () = jvm .invoke_static( @@ -253,25 +253,25 @@ impl CharArrayWriter { } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::size_locked(jvm, this)).await } async fn size_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.CharArrayWriter::size({this:?})"); - jvm.get_field(&this, "count", "I").await + jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::to_string_locked(jvm, this)).await } async fn to_string_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.CharArrayWriter::toString({this:?})"); - let buffer: ClassInstanceRef> = jvm.get_field(&this, "buf", "[C").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&this, "java/io/CharArrayWriter", "buf", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/io/CharArrayWriter", "count", "I").await?; Ok(jvm.new_class("java/lang/String", "([CII)V", (buffer, 0, count)).await?.into()) } diff --git a/rustjava-runtime/src/classes/java/io/data_input_stream.rs b/rustjava-runtime/src/classes/java/io/data_input_stream.rs index 6c7186d0..ed510855 100644 --- a/rustjava-runtime/src/classes/java/io/data_input_stream.rs +++ b/rustjava-runtime/src/classes/java/io/data_input_stream.rs @@ -284,14 +284,14 @@ impl DataInputStream { async fn skip_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, n: i32) -> Result { tracing::debug!("java.io.DataInputStream::skipBytes({this:?}, {n:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/DataInputStream", "in", "Ljava/io/InputStream;").await?; let skipped: i64 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (n as i64,)).await?; Ok(skipped as _) } async fn read_required_byte(jvm: &Jvm, this: &ClassInstanceRef) -> Result { - let r#in = jvm.get_field(this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(this, "java/io/DataInputStream", "in", "Ljava/io/InputStream;").await?; let value: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "read", "()I", ()).await?; if value == -1 { return Err(jvm.exception("java/io/EOFException", "End of stream").await); diff --git a/rustjava-runtime/src/classes/java/io/data_output_stream.rs b/rustjava-runtime/src/classes/java/io/data_output_stream.rs index 9c4a2bfd..b9eaf9c4 100644 --- a/rustjava-runtime/src/classes/java/io/data_output_stream.rs +++ b/rustjava-runtime/src/classes/java/io/data_output_stream.rs @@ -105,7 +105,7 @@ impl DataOutputStream { async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, b: i32) -> Result<()> { tracing::debug!("java.io.DataOutputStream::write({this:?}, {b:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (b,)).await?; Ok(()) @@ -114,7 +114,7 @@ impl DataOutputStream { async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, v: i32) -> Result<()> { tracing::debug!("java.io.DataOutputStream::writeByte({this:?}, {v:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (v,)).await?; Ok(()) @@ -137,7 +137,7 @@ impl DataOutputStream { let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?; jvm.store_array(&mut byte_array, 0, cast_vec::(bytes.to_vec())).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?; Ok(()) @@ -156,7 +156,7 @@ impl DataOutputStream { let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?; jvm.store_array(&mut byte_array, 0, cast_vec::(bytes.to_vec())).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?; Ok(()) @@ -169,7 +169,7 @@ impl DataOutputStream { let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?; jvm.store_array(&mut byte_array, 0, cast_vec::(bytes.to_vec())).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?; Ok(()) @@ -196,7 +196,7 @@ impl DataOutputStream { let mut bytes = jvm.instantiate_array("B", chars.len()).await?; jvm.store_array(&mut bytes, 0, chars.into_iter().map(|value| value as i8)).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await } @@ -215,7 +215,7 @@ impl DataOutputStream { let mut bytes = jvm.instantiate_array("B", data.len()).await?; jvm.store_array(&mut bytes, 0, data).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await } @@ -250,14 +250,14 @@ impl DataOutputStream { let mut bytes = jvm.instantiate_array("B", data.len()).await?; jvm.store_array(&mut bytes, 0, data).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.DataOutputStream::close({this:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", []).await?; Ok(()) @@ -266,7 +266,7 @@ impl DataOutputStream { async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.DataOutputStream::flush({this:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", []).await?; Ok(()) diff --git a/rustjava-runtime/src/classes/java/io/file.rs b/rustjava-runtime/src/classes/java/io/file.rs index c22c9194..654d5d4d 100644 --- a/rustjava-runtime/src/classes/java/io/file.rs +++ b/rustjava-runtime/src/classes/java/io/file.rs @@ -87,7 +87,7 @@ impl File { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "path", "Ljava/lang/String;", pathname).await?; + jvm.put_field(&mut this, "java/io/File", "path", "Ljava/lang/String;", pathname).await?; Ok(()) } @@ -95,7 +95,7 @@ impl File { async fn get_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.File::getPath({this:?})"); - jvm.get_field(&this, "path", "Ljava/lang/String;").await + jvm.get_field(&this, "java/io/File", "path", "Ljava/lang/String;").await } async fn exists(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result { diff --git a/rustjava-runtime/src/classes/java/io/file_descriptor.rs b/rustjava-runtime/src/classes/java/io/file_descriptor.rs index 537231cc..fab44f0a 100644 --- a/rustjava-runtime/src/classes/java/io/file_descriptor.rs +++ b/rustjava-runtime/src/classes/java/io/file_descriptor.rs @@ -35,7 +35,8 @@ impl FileDescriptor { let stderr_fd = runtime.stderr(); if let Ok(stderr_fd) = stderr_fd { let mut stderr = jvm.new_class("java/io/FileDescriptor", "()V", []).await?; - jvm.put_field(&mut stderr, "fd", "I", stderr_fd.id() as i32).await?; + jvm.put_field(&mut stderr, "java/io/FileDescriptor", "fd", "I", stderr_fd.id() as i32) + .await?; jvm.put_static_field("java/io/FileDescriptor", "err", "Ljava/io/FileDescriptor;", stderr) .await?; @@ -44,7 +45,8 @@ impl FileDescriptor { let stdin_fd = runtime.stdin(); if let Ok(stdin_fd) = stdin_fd { let mut stdin = jvm.new_class("java/io/FileDescriptor", "()V", []).await?; - jvm.put_field(&mut stdin, "fd", "I", stdin_fd.id() as i32).await?; + jvm.put_field(&mut stdin, "java/io/FileDescriptor", "fd", "I", stdin_fd.id() as i32) + .await?; jvm.put_static_field("java/io/FileDescriptor", "in", "Ljava/io/FileDescriptor;", stdin) .await?; @@ -53,7 +55,8 @@ impl FileDescriptor { let stdout_fd = runtime.stdout(); if let Ok(stdout_fd) = stdout_fd { let mut stdout = jvm.new_class("java/io/FileDescriptor", "()V", []).await?; - jvm.put_field(&mut stdout, "fd", "I", stdout_fd.id() as i32).await?; + jvm.put_field(&mut stdout, "java/io/FileDescriptor", "fd", "I", stdout_fd.id() as i32) + .await?; jvm.put_static_field("java/io/FileDescriptor", "out", "Ljava/io/FileDescriptor;", stdout) .await?; @@ -72,13 +75,13 @@ impl FileDescriptor { pub async fn from_fd(jvm: &Jvm, fd: crate::FileDescriptorId) -> Result> { let mut this = jvm.new_class("java/io/FileDescriptor", "()V", []).await?; - jvm.put_field(&mut this, "fd", "I", fd.id() as i32).await?; + jvm.put_field(&mut this, "java/io/FileDescriptor", "fd", "I", fd.id() as i32).await?; Ok(this.into()) } pub async fn file(jvm: &Jvm, runtime: &RuntimeContext, this: ClassInstanceRef) -> Result> { - let fd: i32 = jvm.get_field(&this, "fd", "I").await?; + let fd: i32 = jvm.get_field(&this, "java/io/FileDescriptor", "fd", "I").await?; if fd <= 0 { return Err(jvm.exception("java/io/IOException", "Invalid file descriptor").await); } @@ -90,7 +93,7 @@ impl FileDescriptor { } pub async fn close(jvm: &Jvm, runtime: &RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let fd: i32 = jvm.get_field(&this, "fd", "I").await?; + let fd: i32 = jvm.get_field(&this, "java/io/FileDescriptor", "fd", "I").await?; if fd > 0 { runtime.close_file(crate::FileDescriptorId::new(fd as u32)); } diff --git a/rustjava-runtime/src/classes/java/io/file_input_stream.rs b/rustjava-runtime/src/classes/java/io/file_input_stream.rs index 9ed873df..b6ed3a3c 100644 --- a/rustjava-runtime/src/classes/java/io/file_input_stream.rs +++ b/rustjava-runtime/src/classes/java/io/file_input_stream.rs @@ -80,7 +80,8 @@ impl FileInputStream { let _: () = jvm.invoke_special(&this, "java/io/InputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "fd", "Ljava/io/FileDescriptor;", fd).await?; + jvm.put_field(&mut this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;", fd) + .await?; Ok(()) } @@ -88,7 +89,7 @@ impl FileInputStream { async fn available(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.FileInputStream::available({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?; let rust_file = FileDescriptor::file(jvm, context, fd).await?; // TODO get os buffer size @@ -114,7 +115,7 @@ impl FileInputStream { ) -> Result { tracing::debug!("java.io.FileInputStream::read({this:?}, {buf:?}, {offset:?}, {length:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; let mut rust_buf = vec![0; length as _]; @@ -133,7 +134,7 @@ impl FileInputStream { async fn read_byte(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.FileInputStream::read({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; let mut buf = [0; 1]; @@ -150,7 +151,7 @@ impl FileInputStream { async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FileInputStream::close({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?; FileDescriptor::close(jvm, context, fd).await?; Ok(()) diff --git a/rustjava-runtime/src/classes/java/io/file_output_stream.rs b/rustjava-runtime/src/classes/java/io/file_output_stream.rs index e72d02c0..3c15fa00 100644 --- a/rustjava-runtime/src/classes/java/io/file_output_stream.rs +++ b/rustjava-runtime/src/classes/java/io/file_output_stream.rs @@ -77,8 +77,9 @@ impl FileOutputStream { let fd = FileDescriptor::from_fd(jvm, fd.unwrap()).await?; let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "fd", "Ljava/io/FileDescriptor;", fd).await?; - jvm.put_field(&mut this, "append", "Z", append).await + jvm.put_field(&mut this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;", fd) + .await?; + jvm.put_field(&mut this, "java/io/FileOutputStream", "append", "Z", append).await } async fn init_with_file_descriptor( @@ -91,8 +92,9 @@ impl FileOutputStream { let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "fd", "Ljava/io/FileDescriptor;", file_descriptor).await?; - jvm.put_field(&mut this, "append", "Z", false).await?; + jvm.put_field(&mut this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;", file_descriptor) + .await?; + jvm.put_field(&mut this, "java/io/FileOutputStream", "append", "Z", false).await?; Ok(()) } @@ -107,7 +109,7 @@ impl FileOutputStream { ) -> Result<()> { tracing::debug!("java.io.FileOutputStream::write({this:?}, {buffer:?}, {offset:?}, {length:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?; let mut file = FileDescriptor::file(jvm, context, fd).await?; let mut buf = vec![0; length as _]; @@ -129,7 +131,7 @@ impl FileOutputStream { async fn write(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef, byte: i32) -> Result<()> { tracing::debug!("java.io.FileOutputStream::write({this:?}, {byte:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?; let mut file = FileDescriptor::file(jvm, context, fd).await?; if !matches!(file.write(&[byte as u8]).await, Ok(1)) { @@ -142,7 +144,7 @@ impl FileOutputStream { async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FileOutputStream::close({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?; FileDescriptor::close(jvm, context, fd).await?; Ok(()) diff --git a/rustjava-runtime/src/classes/java/io/filter_input_stream.rs b/rustjava-runtime/src/classes/java/io/filter_input_stream.rs index f9412ed1..da4c58e3 100644 --- a/rustjava-runtime/src/classes/java/io/filter_input_stream.rs +++ b/rustjava-runtime/src/classes/java/io/filter_input_stream.rs @@ -37,7 +37,8 @@ impl FilterInputStream { let _: () = jvm.invoke_special(&this, "java/io/InputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", r#in).await?; + jvm.put_field(&mut this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;", r#in) + .await?; Ok(()) } @@ -45,7 +46,7 @@ impl FilterInputStream { async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.FilterInputStream::available({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?; Ok(available) @@ -54,7 +55,7 @@ impl FilterInputStream { async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FilterInputStream::close({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await?; Ok(()) @@ -63,7 +64,7 @@ impl FilterInputStream { async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FilterInputStream::reset({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "reset", "()V", ()).await?; Ok(()) @@ -71,26 +72,26 @@ impl FilterInputStream { async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, n: i64) -> Result { tracing::debug!("java.io.FilterInputStream::skip({this:?}, {n})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (n,)).await } async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, readlimit: i32) -> Result<()> { tracing::debug!("java.io.FilterInputStream::mark({this:?}, {readlimit})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; jvm.invoke_virtual(&r#in, "java/io/InputStream", "mark", "(I)V", (readlimit,)).await } async fn mark_supported(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.FilterInputStream::markSupported({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; jvm.invoke_virtual(&r#in, "java/io/InputStream", "markSupported", "()Z", ()).await } async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, b: ClassInstanceRef>) -> Result { tracing::debug!("java.io.FilterInputStream::read({this:?}, {b:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let result: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "read", "([B)I", (b,)).await?; Ok(result) @@ -106,7 +107,7 @@ impl FilterInputStream { ) -> Result { tracing::debug!("java.io.FilterInputStream::read({this:?}, {b:?}, {off}, {len})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let result: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "read", "([BII)I", (b, off, len)).await?; Ok(result) @@ -115,7 +116,7 @@ impl FilterInputStream { async fn read_byte_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.FilterInputStream::read({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/FilterInputStream", "in", "Ljava/io/InputStream;").await?; let result: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "read", "()I", ()).await?; Ok(result) diff --git a/rustjava-runtime/src/classes/java/io/filter_output_stream.rs b/rustjava-runtime/src/classes/java/io/filter_output_stream.rs index 0329555b..09259da2 100644 --- a/rustjava-runtime/src/classes/java/io/filter_output_stream.rs +++ b/rustjava-runtime/src/classes/java/io/filter_output_stream.rs @@ -32,7 +32,8 @@ impl FilterOutputStream { let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", out).await?; + jvm.put_field(&mut this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;", out) + .await?; Ok(()) } @@ -47,7 +48,9 @@ impl FilterOutputStream { ) -> Result<()> { tracing::debug!(" java.io.FilterOutputStream::write({this:?}, {bytes:?}, {offset:?}, {length:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;") + .await?; let _: () = jvm .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, offset, length)) .await?; @@ -58,7 +61,9 @@ impl FilterOutputStream { async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, byte: i32) -> Result<()> { tracing::debug!("java.io.FilterOutputStream::write({this:?}, {byte:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;") + .await?; let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (byte,)).await?; Ok(()) @@ -66,14 +71,18 @@ impl FilterOutputStream { async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FilterOutputStream::flush({this:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;") + .await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.FilterOutputStream::close({this:?})"); - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm + .get_field(&this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;") + .await?; if out.is_null() { return Ok(()); } @@ -83,14 +92,16 @@ impl FilterOutputStream { Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {} Err(error) => { let null_output: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", null_output).await?; + jvm.put_field(&mut this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;", null_output) + .await?; return Err(error); } } let close_result: Result<()> = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await; let null_output: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", null_output).await?; + jvm.put_field(&mut this, "java/io/FilterOutputStream", "out", "Ljava/io/OutputStream;", null_output) + .await?; close_result } } diff --git a/rustjava-runtime/src/classes/java/io/input_stream_reader.rs b/rustjava-runtime/src/classes/java/io/input_stream_reader.rs index ad2805be..4e1d3600 100644 --- a/rustjava-runtime/src/classes/java/io/input_stream_reader.rs +++ b/rustjava-runtime/src/classes/java/io/input_stream_reader.rs @@ -87,18 +87,20 @@ impl InputStreamReader { let _: () = jvm.invoke_special(&this, "java/io/Reader", "", "()V", ()).await?; let charset = JavaLangString::from_rust_string(jvm, charset_name).await?; - jvm.put_field(&mut this, "charset", "Ljava/lang/String;", charset).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "charset", "Ljava/lang/String;", charset) + .await?; let read_buf = jvm.instantiate_array("B", BUF_SIZE).await?; - jvm.put_field(&mut this, "readBuf", "[B", read_buf).await?; - jvm.put_field(&mut this, "readBufSize", "I", 0).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "readBuf", "[B", read_buf).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "readBufSize", "I", 0).await?; let write_buf = jvm.instantiate_array("C", BUF_SIZE * 3).await?; - jvm.put_field(&mut this, "writeBuf", "[C", write_buf).await?; - jvm.put_field(&mut this, "writeBufSize", "I", 0).await?; - jvm.put_field(&mut this, "endOfInput", "Z", false).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBuf", "[C", write_buf).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", 0).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "endOfInput", "Z", false).await?; - jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", r#in).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;", r#in) + .await?; Ok(()) } @@ -121,16 +123,16 @@ impl InputStreamReader { return Ok(0); } - let mut write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?; + let mut write_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?; while write_buf_size < length { - let read_buf: ClassInstanceRef> = jvm.get_field(&this, "readBuf", "[B").await?; - let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?; + let read_buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/InputStreamReader", "readBuf", "[B").await?; + let read_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "readBufSize", "I").await?; if read_buf_size < (BUF_SIZE / 2) as _ { let bytes_to_read = BUF_SIZE as i32 - read_buf_size; - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?; let temp = jvm.instantiate_array("B", bytes_to_read as _).await?; let read: i32 = jvm @@ -145,20 +147,21 @@ impl InputStreamReader { (temp, 0, read_buf.clone(), read_buf_size, read), ) .await?; - jvm.put_field(&mut this, "readBufSize", "I", read_buf_size + read).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "readBufSize", "I", read_buf_size + read) + .await?; } else { - jvm.put_field(&mut this, "endOfInput", "Z", true).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "endOfInput", "Z", true).await?; if read_buf_size == 0 && write_buf_size == 0 { return Ok(-1); } } } - let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?; + let read_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "readBufSize", "I").await?; let mut read_buf_data = vec![0; read_buf_size as _]; jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data)?; - let charset_ref = jvm.get_field(&this, "charset", "Ljava/lang/String;").await?; + let charset_ref = jvm.get_field(&this, "java/io/InputStreamReader", "charset", "Ljava/lang/String;").await?; let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?; let mut decoder = if charset == "UTF-8" { UTF_8.new_decoder_without_bom_handling() @@ -169,7 +172,7 @@ impl InputStreamReader { }; let read_buf_data: Vec = cast_vec(read_buf_data); - let end_of_input: bool = jvm.get_field(&this, "endOfInput", "Z").await?; + let end_of_input: bool = jvm.get_field(&this, "java/io/InputStreamReader", "endOfInput", "Z").await?; let mut decode_length = read_buf_data.len(); if !end_of_input && charset == "UTF-8" && decode_length > 0 { let mut lead_index = decode_length - 1; @@ -201,11 +204,12 @@ impl InputStreamReader { (read_buf.clone(), read as i32, read_buf, 0, (read_buf_size - read as i32)), ) .await?; - jvm.put_field(&mut this, "readBufSize", "I", read_buf_size - read as i32).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "readBufSize", "I", read_buf_size - read as i32) + .await?; // add to writeBuf - let mut write_buf = jvm.get_field(&this, "writeBuf", "[C").await?; - let buffered_chars: i32 = jvm.get_field(&this, "writeBufSize", "I").await?; + let mut write_buf = jvm.get_field(&this, "java/io/InputStreamReader", "writeBuf", "[C").await?; + let buffered_chars: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?; jvm.store_array( &mut write_buf, buffered_chars as _, @@ -213,14 +217,15 @@ impl InputStreamReader { ) .await?; write_buf_size = buffered_chars + wrote as i32; - jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", write_buf_size) + .await?; if write_buf_size > 0 { break; } } - let write_buf: ClassInstanceRef> = jvm.get_field(&this, "writeBuf", "[C").await?; - let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?; + let write_buf: ClassInstanceRef> = jvm.get_field(&this, "java/io/InputStreamReader", "writeBuf", "[C").await?; + let write_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?; let to_copy = min(length, write_buf_size); @@ -242,7 +247,8 @@ impl InputStreamReader { (write_buf.clone(), to_copy, write_buf, 0, write_buf_size - to_copy), ) .await?; - jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size - to_copy).await?; + jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", write_buf_size - to_copy) + .await?; Ok(to_copy) } @@ -250,7 +256,7 @@ impl InputStreamReader { async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.InputStreamReader::close({this:?})"); - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?; let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await?; Ok(()) @@ -259,12 +265,12 @@ impl InputStreamReader { async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.InputStreamReader::ready({this:?})"); - let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?; + let write_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?; if write_buf_size > 0 { return Ok(true); } - let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?; + let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?; let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?; Ok(available > 0) } diff --git a/rustjava-runtime/src/classes/java/io/interrupted_io_exception.rs b/rustjava-runtime/src/classes/java/io/interrupted_io_exception.rs index 7f05847c..403b18f1 100644 --- a/rustjava-runtime/src/classes/java/io/interrupted_io_exception.rs +++ b/rustjava-runtime/src/classes/java/io/interrupted_io_exception.rs @@ -27,7 +27,8 @@ impl InterruptedIOException { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.InterruptedIOException::({this:?})"); let _: () = jvm.invoke_special(&this, "java/io/IOException", "", "()V", ()).await?; - jvm.put_field(&mut this, "bytesTransferred", "I", 0).await + jvm.put_field(&mut this, "java/io/InterruptedIOException", "bytesTransferred", "I", 0) + .await } async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, message: ClassInstanceRef) -> Result<()> { @@ -35,6 +36,7 @@ impl InterruptedIOException { let _: () = jvm .invoke_special(&this, "java/io/IOException", "", "(Ljava/lang/String;)V", (message,)) .await?; - jvm.put_field(&mut this, "bytesTransferred", "I", 0).await + jvm.put_field(&mut this, "java/io/InterruptedIOException", "bytesTransferred", "I", 0) + .await } } diff --git a/rustjava-runtime/src/classes/java/io/output_stream_writer.rs b/rustjava-runtime/src/classes/java/io/output_stream_writer.rs index d6e2434d..2b82dd01 100644 --- a/rustjava-runtime/src/classes/java/io/output_stream_writer.rs +++ b/rustjava-runtime/src/classes/java/io/output_stream_writer.rs @@ -73,9 +73,12 @@ impl OutputStreamWriter { Self::validate_encoding(jvm, &encoding).await?; let _: () = jvm.invoke_special(&this, "java/io/Writer", "", "()V", ()).await?; - jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", out).await?; - jvm.put_field(&mut this, "encoding", "Ljava/lang/String;", encoding).await?; - jvm.put_field(&mut this, "hasPendingHighSurrogate", "Z", false).await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;", out) + .await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "encoding", "Ljava/lang/String;", encoding) + .await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false) + .await?; Ok(()) } @@ -110,25 +113,30 @@ impl OutputStreamWriter { } let mut utf16: Vec = jvm.load_array(&chars, off as usize, len as usize).await?; - let has_pending: bool = jvm.get_field(&this, "hasPendingHighSurrogate", "Z").await?; + let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?; if has_pending { - let pending: JavaChar = jvm.get_field(&this, "pendingHighSurrogate", "C").await?; + let pending: JavaChar = jvm.get_field(&this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C").await?; utf16.insert(0, pending); - jvm.put_field(&mut this, "hasPendingHighSurrogate", "Z", false).await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false) + .await?; } if utf16.last().is_some_and(|value| (0xd800..=0xdbff).contains(value)) { let Some(pending) = utf16.pop() else { return Ok(()); }; - jvm.put_field(&mut this, "pendingHighSurrogate", "C", pending).await?; - jvm.put_field(&mut this, "hasPendingHighSurrogate", "Z", true).await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C", pending) + .await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", true) + .await?; } if utf16.is_empty() { return Ok(()); } let value: RustString = char::decode_utf16(utf16).map(|value| value.unwrap_or('?')).collect(); - let encoding: ClassInstanceRef = jvm.get_field(&this, "encoding", "Ljava/lang/String;").await?; + let encoding: ClassInstanceRef = jvm + .get_field(&this, "java/io/OutputStreamWriter", "encoding", "Ljava/lang/String;") + .await?; let encoding = JavaLangString::to_rust_string(jvm, &encoding).await?.to_ascii_uppercase(); let bytes = if matches!(encoding.as_str(), "UTF-8" | "UTF8") { value.into_bytes() @@ -139,22 +147,27 @@ impl OutputStreamWriter { let mut java_bytes = jvm.instantiate_array("B", bytes.len()).await?; jvm.store_array(&mut java_bytes, 0, bytes.into_iter().map(|value| value as i8)).await?; - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;") + .await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (java_bytes,)).await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.OutputStreamWriter::flush({this:?})"); - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;") + .await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.OutputStreamWriter::close({this:?})"); - let has_pending: bool = jvm.get_field(&this, "hasPendingHighSurrogate", "Z").await?; + let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?; if has_pending { - jvm.put_field(&mut this, "hasPendingHighSurrogate", "Z", false).await?; + jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false) + .await?; let mut replacement = jvm.instantiate_array("C", 1).await?; jvm.store_array(&mut replacement, 0, ['?' as JavaChar]).await?; let _: () = jvm @@ -162,7 +175,9 @@ impl OutputStreamWriter { .await?; } - let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out = jvm + .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;") + .await?; jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await } } diff --git a/rustjava-runtime/src/classes/java/io/print_stream.rs b/rustjava-runtime/src/classes/java/io/print_stream.rs index 3d08d204..dd1af98b 100644 --- a/rustjava-runtime/src/classes/java/io/print_stream.rs +++ b/rustjava-runtime/src/classes/java/io/print_stream.rs @@ -207,10 +207,11 @@ impl PrintStream { (this_output, encoding), ) .await?; - jvm.put_field(&mut this, "autoFlush", "Z", auto_flush).await?; - jvm.put_field(&mut this, "trouble", "Z", false).await?; - jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", char_out).await?; - jvm.put_field(&mut this, "closing", "Z", false).await + jvm.put_field(&mut this, "java/io/PrintStream", "autoFlush", "Z", auto_flush).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", false).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", char_out) + .await?; + jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", false).await } async fn init_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, path: ClassInstanceRef) -> Result<()> { @@ -298,39 +299,41 @@ impl PrintStream { tracing::debug!("java.io.PrintStream::checkError({this:?})"); Self::with_monitor(jvm, &this, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if !out.is_null() { let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "flush", "()V", ()).await?; if jvm.is_instance(&**out, "java/io/PrintStream") { return jvm.invoke_virtual(&out, "java/io/PrintStream", "checkError", "()Z", ()).await; } } - jvm.get_field(&this, "trouble", "Z").await + jvm.get_field(&this, "java/io/PrintStream", "trouble", "Z").await }) .await } async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "trouble", "Z", true).await + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.PrintStream::close({this:?})"); Self::with_monitor(jvm, &this, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; - if out.is_null() || jvm.get_field::(&this, "closing", "Z").await? { + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; + if out.is_null() || jvm.get_field::(&this, "java/io/PrintStream", "closing", "Z").await? { return Ok(()); } let mut this = this.clone(); - jvm.put_field(&mut this, "closing", "Z", true).await?; - let char_out: ClassInstanceRef = jvm.get_field(&this, "charOut", "Ljava/io/OutputStreamWriter;").await?; + jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", true).await?; + let char_out: ClassInstanceRef = jvm + .get_field(&this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; let char_out_result = jvm.invoke_virtual(&char_out, "java/io/OutputStreamWriter", "close", "()V", ()).await; let close_out = match char_out_result { Ok(()) => true, Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; false } Err(error) => return Err(error), @@ -340,7 +343,7 @@ impl PrintStream { match jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await { Ok(()) => {} Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; } Err(error) => return Err(error), } @@ -348,8 +351,10 @@ impl PrintStream { let closed_output: ClassInstanceRef = None.into(); let closed_writer: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", closed_writer).await?; - jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", closed_output).await + jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", closed_writer) + .await?; + jvm.put_field(&mut this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;", closed_output) + .await }) .await } @@ -358,10 +363,10 @@ impl PrintStream { tracing::debug!("java.io.PrintStream::flush({this:?})"); Self::with_monitor(jvm, &this, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; return Ok(()); } @@ -375,17 +380,17 @@ impl PrintStream { tracing::debug!("java.io.PrintStream::write({this:?}, {value})"); Self::with_monitor(jvm, &this, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; return Ok(()); } let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (value,)).await; if Self::suppress_io_exception(jvm, &this, result).await? && value == b'\n' as i32 - && jvm.get_field::(&this, "autoFlush", "Z").await? + && jvm.get_field::(&this, "java/io/PrintStream", "autoFlush", "Z").await? { let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await; Self::suppress_io_exception(jvm, &this, result).await?; @@ -414,17 +419,18 @@ impl PrintStream { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await); } - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; return Ok(()); } let result = jvm .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, off, len)) .await; - if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::(&this, "autoFlush", "Z").await? { + if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::(&this, "java/io/PrintStream", "autoFlush", "Z").await? + { let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await; Self::suppress_io_exception(jvm, &this, result).await?; } @@ -731,16 +737,18 @@ impl PrintStream { return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await); } - let out: ClassInstanceRef = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; return Ok(()); } let length = jvm.array_length(&chars).await?; let values: Vec = jvm.load_array(&chars, 0, length).await?; - let char_out: ClassInstanceRef = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?; + let char_out: ClassInstanceRef = jvm + .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; let result = jvm .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32)) .await; @@ -748,7 +756,7 @@ impl PrintStream { return Ok(()); } - if jvm.get_field::(this, "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) { + if jvm.get_field::(this, "java/io/PrintStream", "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) { let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await; Self::suppress_io_exception(jvm, this, result).await?; } @@ -759,10 +767,10 @@ impl PrintStream { async fn new_line(jvm: &Jvm, this: &ClassInstanceRef) -> Result<()> { Self::with_monitor(jvm, this, async { - let out: ClassInstanceRef = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?; + let out: ClassInstanceRef = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; return Ok(()); } @@ -777,7 +785,9 @@ impl PrintStream { }; let chars: ClassInstanceRef> = jvm.invoke_virtual(&separator, "java/lang/String", "toCharArray", "()[C", ()).await?; let length = jvm.array_length(&chars).await?; - let char_out: ClassInstanceRef = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?; + let char_out: ClassInstanceRef = jvm + .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; let result = jvm .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32)) .await; @@ -785,7 +795,7 @@ impl PrintStream { return Ok(()); } - if jvm.get_field::(this, "autoFlush", "Z").await? { + if jvm.get_field::(this, "java/io/PrintStream", "autoFlush", "Z").await? { let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await; Self::suppress_io_exception(jvm, this, result).await?; } @@ -799,7 +809,7 @@ impl PrintStream { Ok(()) => Ok(true), Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?; Ok(false) } Err(error) => Err(error), diff --git a/rustjava-runtime/src/classes/java/io/print_writer.rs b/rustjava-runtime/src/classes/java/io/print_writer.rs index 5a2f8408..06f98aa8 100644 --- a/rustjava-runtime/src/classes/java/io/print_writer.rs +++ b/rustjava-runtime/src/classes/java/io/print_writer.rs @@ -181,9 +181,9 @@ impl PrintWriter { let _: () = jvm .invoke_special(&this, "java/io/Writer", "", "(Ljava/lang/Object;)V", (out.clone(),)) .await?; - jvm.put_field(&mut this, "out", "Ljava/io/Writer;", out).await?; - jvm.put_field(&mut this, "autoFlush", "Z", auto_flush).await?; - jvm.put_field(&mut this, "trouble", "Z", false).await + jvm.put_field(&mut this, "java/io/PrintWriter", "out", "Ljava/io/Writer;", out).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "autoFlush", "Z", auto_flush).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", false).await } async fn init_output_stream(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, out: ClassInstanceRef) -> Result<()> { @@ -305,12 +305,12 @@ impl PrintWriter { async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: i32) -> Result<()> { tracing::debug!("java.io.PrintWriter::write({this:?}, {value})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } @@ -323,7 +323,7 @@ impl PrintWriter { async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, chars: ClassInstanceRef>) -> Result<()> { tracing::debug!("java.io.PrintWriter::write({this:?}, {chars:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { if chars.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await); @@ -345,7 +345,7 @@ impl PrintWriter { ) -> Result<()> { tracing::debug!("java.io.PrintWriter::write({this:?}, {chars:?}, {offset}, {length})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { if chars.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await); @@ -355,10 +355,10 @@ impl PrintWriter { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await); } - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } @@ -373,7 +373,7 @@ impl PrintWriter { async fn write_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, string: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.PrintWriter::write({this:?}, {string:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { if string.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "string is null").await); @@ -395,7 +395,7 @@ impl PrintWriter { ) -> Result<()> { tracing::debug!("java.io.PrintWriter::write({this:?}, {string:?}, {offset}, {length})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { if string.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "string is null").await); @@ -405,10 +405,10 @@ impl PrintWriter { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await); } - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } @@ -492,12 +492,12 @@ impl PrintWriter { async fn println(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.PrintWriter::println({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } @@ -517,13 +517,13 @@ impl PrintWriter { Ok(()) => {} Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } Err(error) => return Err(error), } - if jvm.get_field::(&this, "autoFlush", "Z").await? { + if jvm.get_field::(&this, "java/io/PrintWriter", "autoFlush", "Z").await? { let result = jvm.invoke_virtual(&out, "java/io/Writer", "flush", "()V", ()).await; Self::suppress_io_exception(jvm, &this, result).await } else { @@ -534,7 +534,7 @@ impl PrintWriter { } async fn println_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: bool) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(Z)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -543,7 +543,7 @@ impl PrintWriter { } async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: JavaChar) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(C)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -552,7 +552,7 @@ impl PrintWriter { } async fn println_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: i32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(I)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -561,7 +561,7 @@ impl PrintWriter { } async fn println_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: i64) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(J)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -570,7 +570,7 @@ impl PrintWriter { } async fn println_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: f32) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(F)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -579,7 +579,7 @@ impl PrintWriter { } async fn println_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: f64) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "(D)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -588,7 +588,7 @@ impl PrintWriter { } async fn println_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef>) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "print", "([C)V", (value,)).await?; jvm.invoke_virtual(&this, "java/io/PrintWriter", "println", "()V", ()).await @@ -597,7 +597,7 @@ impl PrintWriter { } async fn println_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm .invoke_virtual(&this, "java/io/PrintWriter", "print", "(Ljava/lang/String;)V", (value,)) @@ -608,7 +608,7 @@ impl PrintWriter { } async fn println_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let _: () = jvm .invoke_virtual(&this, "java/io/PrintWriter", "print", "(Ljava/lang/Object;)V", (value,)) @@ -621,12 +621,12 @@ impl PrintWriter { async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.PrintWriter::flush({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await?; + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await?; return Ok(()); } @@ -639,9 +639,9 @@ impl PrintWriter { async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.PrintWriter::close({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if out.is_null() { return Ok(()); } @@ -650,11 +650,11 @@ impl PrintWriter { Ok(()) => { let mut this = this.clone(); let closed: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "out", "Ljava/io/Writer;", closed).await + jvm.put_field(&mut this, "java/io/PrintWriter", "out", "Ljava/io/Writer;", closed).await } Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await } Err(error) => Err(error), } @@ -665,22 +665,22 @@ impl PrintWriter { async fn check_error(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.PrintWriter::checkError({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { - let out: ClassInstanceRef = jvm.get_field(&this, "out", "Ljava/io/Writer;").await?; + let out: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; if !out.is_null() { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "flush", "()V", ()).await?; if jvm.is_instance(&**out, "java/io/PrintWriter") { return jvm.invoke_virtual(&out, "java/io/PrintWriter", "checkError", "()Z", ()).await; } } - jvm.get_field(&this, "trouble", "Z").await + jvm.get_field(&this, "java/io/PrintWriter", "trouble", "Z").await }) .await } async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "trouble", "Z", true).await + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await } async fn printf( @@ -744,7 +744,7 @@ impl PrintWriter { format: ClassInstanceRef, arguments: ClassInstanceRef>, ) -> Result> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/PrintWriter", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, async { let appendable: ClassInstanceRef = this.instance.clone().into(); let formatter: ClassInstanceRef = jvm @@ -760,7 +760,7 @@ impl PrintWriter { (format, arguments), ) .await?; - if jvm.get_field::(&this, "autoFlush", "Z").await? { + if jvm.get_field::(&this, "java/io/PrintWriter", "autoFlush", "Z").await? { let _: () = jvm.invoke_virtual(&this, "java/io/PrintWriter", "flush", "()V", ()).await?; } Ok(this.clone()) @@ -818,7 +818,7 @@ impl PrintWriter { Ok(()) => Ok(()), Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { let mut this = this.clone(); - jvm.put_field(&mut this, "trouble", "Z", true).await + jvm.put_field(&mut this, "java/io/PrintWriter", "trouble", "Z", true).await } Err(error) => Err(error), } diff --git a/rustjava-runtime/src/classes/java/io/random_access_file.rs b/rustjava-runtime/src/classes/java/io/random_access_file.rs index 59ab137e..56927744 100644 --- a/rustjava-runtime/src/classes/java/io/random_access_file.rs +++ b/rustjava-runtime/src/classes/java/io/random_access_file.rs @@ -87,7 +87,8 @@ impl RandomAccessFile { return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await); } let fd = FileDescriptor::from_fd(jvm, fd_id.unwrap()).await?; - jvm.put_field(&mut this, "fd", "Ljava/io/FileDescriptor;", fd).await?; + jvm.put_field(&mut this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;", fd) + .await?; Ok(()) } @@ -137,7 +138,7 @@ impl RandomAccessFile { ) -> Result { tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?}, {offset:?}, {length:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; let mut rust_buf = vec![0; length as usize]; @@ -171,7 +172,7 @@ impl RandomAccessFile { ) -> Result<()> { tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?}, {offset:?}, {length:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; let mut rust_buf = vec![0; length as usize]; @@ -192,7 +193,7 @@ impl RandomAccessFile { async fn seek(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef, pos: i64) -> Result<()> { tracing::debug!("java.io.RandomAccessFile::seek({this:?}, {pos:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; if rust_file.seek(pos as _).await.is_err() { @@ -205,7 +206,7 @@ impl RandomAccessFile { async fn set_length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef, new_length: i64) -> Result<()> { tracing::debug!("java.io.RandomAccessFile::setLength({this:?}, {new_length:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let mut rust_file = FileDescriptor::file(jvm, context, fd).await?; if rust_file.set_len(new_length as _).await.is_err() { @@ -218,7 +219,7 @@ impl RandomAccessFile { async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.RandomAccessFile::length({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let rust_file = FileDescriptor::file(jvm, context, fd).await?; let Ok(metadata) = rust_file.metadata().await else { @@ -232,7 +233,7 @@ impl RandomAccessFile { async fn get_file_pointer(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.RandomAccessFile::getFilePointer({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; let rust_file = FileDescriptor::file(jvm, context, fd).await?; let Ok(pos) = rust_file.tell().await else { @@ -245,7 +246,7 @@ impl RandomAccessFile { async fn get_fd(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.RandomAccessFile::getFD({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; Ok(fd) } @@ -253,7 +254,7 @@ impl RandomAccessFile { async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.RandomAccessFile::close({this:?})"); - let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?; + let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?; FileDescriptor::close(jvm, context, fd).await?; Ok(()) diff --git a/rustjava-runtime/src/classes/java/io/reader.rs b/rustjava-runtime/src/classes/java/io/reader.rs index 4aff769c..5c87c030 100644 --- a/rustjava-runtime/src/classes/java/io/reader.rs +++ b/rustjava-runtime/src/classes/java/io/reader.rs @@ -51,7 +51,7 @@ impl Reader { } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "lock", "Ljava/lang/Object;", lock).await?; + jvm.put_field(&mut this, "java/io/Reader", "lock", "Ljava/lang/Object;", lock).await?; Ok(()) } diff --git a/rustjava-runtime/src/classes/java/io/string_reader.rs b/rustjava-runtime/src/classes/java/io/string_reader.rs index bd7e0fc1..63c7ce87 100644 --- a/rustjava-runtime/src/classes/java/io/string_reader.rs +++ b/rustjava-runtime/src/classes/java/io/string_reader.rs @@ -49,10 +49,11 @@ impl StringReader { } let _: () = jvm.invoke_special(&this, "java/io/Reader", "", "()V", ()).await?; let length: i32 = jvm.invoke_virtual(&value, "java/lang/String", "length", "()I", ()).await?; - jvm.put_field(&mut this, "str", "Ljava/lang/String;", value).await?; - jvm.put_field(&mut this, "length", "I", length).await?; - jvm.put_field(&mut this, "next", "I", 0).await?; - jvm.put_field(&mut this, "mark", "I", 0).await + jvm.put_field(&mut this, "java/io/StringReader", "str", "Ljava/lang/String;", value) + .await?; + jvm.put_field(&mut this, "java/io/StringReader", "length", "I", length).await?; + jvm.put_field(&mut this, "java/io/StringReader", "next", "I", 0).await?; + jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", 0).await } async fn with_lock(jvm: &Jvm, lock: &ClassInstanceRef, operation: F) -> Result @@ -75,24 +76,24 @@ impl StringReader { } async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await } async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.io.StringReader::read({this:?})"); - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let next: i32 = jvm.get_field(&this, "next", "I").await?; - let length: i32 = jvm.get_field(&this, "length", "I").await?; + let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?; + let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?; if next >= length { return Ok(-1); } let result: JavaChar = jvm.invoke_virtual(&value, "java/lang/String", "charAt", "(I)C", (next,)).await?; - jvm.put_field(&mut this, "next", "I", next + 1).await?; + jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + 1).await?; Ok(result as i32) } @@ -104,7 +105,7 @@ impl StringReader { offset: i32, length: i32, ) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await } @@ -117,7 +118,7 @@ impl StringReader { ) -> Result { tracing::debug!("java.io.StringReader::read({this:?}, {target:?}, {offset}, {length})"); - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -132,8 +133,8 @@ impl StringReader { return Ok(0); } - let next: i32 = jvm.get_field(&this, "next", "I").await?; - let source_length: i32 = jvm.get_field(&this, "length", "I").await?; + let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?; + let source_length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?; if next >= source_length { return Ok(-1); } @@ -141,41 +142,42 @@ impl StringReader { let _: () = jvm .invoke_virtual(&value, "java/lang/String", "getChars", "(II[CI)V", (next, next + copied, target, offset)) .await?; - jvm.put_field(&mut this, "next", "I", next + copied).await?; + jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + copied).await?; Ok(copied) } async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, amount: i64) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, amount)).await } async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef, amount: i64) -> Result { tracing::debug!("java.io.StringReader::skip({this:?}, {amount})"); - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } if amount <= 0 { return Ok(0); } - let next: i32 = jvm.get_field(&this, "next", "I").await?; - let length: i32 = jvm.get_field(&this, "length", "I").await?; + let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?; + let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?; let skipped = amount.min((length - next) as i64); - jvm.put_field(&mut this, "next", "I", next + skipped as i32).await?; + jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + skipped as i32) + .await?; Ok(skipped) } async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await } async fn ready_locked(jvm: &Jvm, this: ClassInstanceRef) -> Result { tracing::debug!("java.io.StringReader::ready({this:?})"); - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } @@ -193,37 +195,37 @@ impl StringReader { if read_ahead_limit < 0 { return Err(jvm.exception("java/lang/IllegalArgumentException", "Read-ahead limit < 0").await); } - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this)).await } async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let next: i32 = jvm.get_field(&this, "next", "I").await?; - jvm.put_field(&mut this, "mark", "I", next).await + let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?; + jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", next).await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await } async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.io.StringReader::reset({this:?})"); - let value: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?; if value.is_null() { return Err(jvm.exception("java/io/IOException", "Stream closed").await); } - let mark: i32 = jvm.get_field(&this, "mark", "I").await?; - jvm.put_field(&mut this, "next", "I", mark).await + let mark: i32 = jvm.get_field(&this, "java/io/StringReader", "mark", "I").await?; + jvm.put_field(&mut this, "java/io/StringReader", "next", "I", mark).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?; Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await } @@ -231,6 +233,7 @@ impl StringReader { tracing::debug!("java.io.StringReader::close({this:?})"); let null_string: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "str", "Ljava/lang/String;", null_string).await + jvm.put_field(&mut this, "java/io/StringReader", "str", "Ljava/lang/String;", null_string) + .await } } diff --git a/rustjava-runtime/src/classes/java/io/string_writer.rs b/rustjava-runtime/src/classes/java/io/string_writer.rs index 71c7b107..ca51b2eb 100644 --- a/rustjava-runtime/src/classes/java/io/string_writer.rs +++ b/rustjava-runtime/src/classes/java/io/string_writer.rs @@ -40,7 +40,8 @@ impl StringWriter { let _: () = jvm.invoke_special(&this, "java/io/Writer", "", "()V", ()).await?; let buf = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?; - jvm.put_field(&mut this, "buf", "Ljava/lang/StringBuffer;", buf).await?; + jvm.put_field(&mut this, "java/io/StringWriter", "buf", "Ljava/lang/StringBuffer;", buf) + .await?; Ok(()) } @@ -55,7 +56,7 @@ impl StringWriter { ) -> Result<()> { tracing::debug!("java.io.StringWriter::write({this:?}, {chars:?}, {off:?}, {len:?})"); - let buf = jvm.get_field(&this, "buf", "Ljava/lang/StringBuffer;").await?; + let buf = jvm.get_field(&this, "java/io/StringWriter", "buf", "Ljava/lang/StringBuffer;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( @@ -83,7 +84,7 @@ impl StringWriter { async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.io.StringWriter::toString({this:?})"); - let buf = jvm.get_field(&this, "buf", "Ljava/lang/StringBuffer;").await?; + let buf = jvm.get_field(&this, "java/io/StringWriter", "buf", "Ljava/lang/StringBuffer;").await?; let string = jvm .invoke_virtual(&buf, "java/lang/StringBuffer", "toString", "()Ljava/lang/String;", ()) diff --git a/rustjava-runtime/src/classes/java/io/writer.rs b/rustjava-runtime/src/classes/java/io/writer.rs index 8590ff63..4639183f 100644 --- a/rustjava-runtime/src/classes/java/io/writer.rs +++ b/rustjava-runtime/src/classes/java/io/writer.rs @@ -83,7 +83,7 @@ impl Writer { } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "lock", "Ljava/lang/Object;", lock).await?; + jvm.put_field(&mut this, "java/io/Writer", "lock", "Ljava/lang/Object;", lock).await?; Ok(()) } diff --git a/rustjava-runtime/src/classes/java/lang/abstract_string_builder.rs b/rustjava-runtime/src/classes/java/lang/abstract_string_builder.rs index 3c239eeb..a1b86ae5 100644 --- a/rustjava-runtime/src/classes/java/lang/abstract_string_builder.rs +++ b/rustjava-runtime/src/classes/java/lang/abstract_string_builder.rs @@ -257,29 +257,30 @@ impl AbstractStringBuilder { return Err(jvm.exception("java/lang/NegativeArraySizeException", &capacity.to_string()).await); } let value = jvm.instantiate_array("C", capacity as usize).await?; - jvm.put_field(&mut this, "value", "[C", value).await?; - jvm.put_field(&mut this, "count", "I", 0).await + jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", value).await?; + jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "count", "I", 0).await } async fn characters(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let count: i32 = jvm.get_field(this, "count", "I").await?; - let value: ClassInstanceRef> = jvm.get_field(this, "value", "[C").await?; + let count: i32 = jvm.get_field(this, "java/lang/AbstractStringBuilder", "count", "I").await?; + let value: ClassInstanceRef> = jvm.get_field(this, "java/lang/AbstractStringBuilder", "value", "[C").await?; jvm.load_array(&value, 0, count as usize).await } async fn replace_characters(jvm: &Jvm, this: &mut ClassInstanceRef, characters: Vec) -> Result<()> { - let value: ClassInstanceRef> = jvm.get_field(this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(this, "java/lang/AbstractStringBuilder", "value", "[C").await?; let old_capacity = jvm.array_length(&value).await?; if characters.len() > old_capacity { let new_capacity = characters.len().max(old_capacity.saturating_mul(2).saturating_add(2)); let mut new_value = jvm.instantiate_array("C", new_capacity).await?; jvm.store_array(&mut new_value, 0, characters.clone()).await?; - jvm.put_field(this, "value", "[C", new_value).await?; + jvm.put_field(this, "java/lang/AbstractStringBuilder", "value", "[C", new_value).await?; } else if !characters.is_empty() { let mut value = value; jvm.store_array(&mut value, 0, characters.clone()).await?; } - jvm.put_field(this, "count", "I", characters.len() as i32).await + jvm.put_field(this, "java/lang/AbstractStringBuilder", "count", "I", characters.len() as i32) + .await } async fn insert_characters(jvm: &Jvm, this: &mut ClassInstanceRef, offset: i32, inserted: Vec) -> Result<()> { @@ -317,11 +318,11 @@ impl AbstractStringBuilder { } async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "count", "I").await + jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await } async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "value", "[C").await?; Ok(jvm.array_length(&value).await? as i32) } @@ -329,7 +330,7 @@ impl AbstractStringBuilder { if minimum_capacity <= 0 { return Ok(()); } - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "value", "[C").await?; let old_capacity = jvm.array_length(&value).await? as i32; if minimum_capacity <= old_capacity { return Ok(()); @@ -338,14 +339,15 @@ impl AbstractStringBuilder { let characters = Self::characters(jvm, &this).await?; let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?; jvm.store_array(&mut new_value, 0, characters).await?; - jvm.put_field(&mut this, "value", "[C", new_value).await + jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", new_value) + .await } async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { let characters = Self::characters(jvm, &this).await?; let mut value = jvm.instantiate_array("C", characters.len()).await?; jvm.store_array(&mut value, 0, characters).await?; - jvm.put_field(&mut this, "value", "[C", value).await + jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", value).await } async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, new_length: i32) -> Result<()> { @@ -768,7 +770,7 @@ impl AbstractStringBuilder { } async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, start: i32) -> Result> { - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await?; jvm.invoke_virtual( &this, "java/lang/AbstractStringBuilder", @@ -1048,7 +1050,7 @@ impl AbstractStringBuilder { } async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, string: ClassInstanceRef) -> Result { - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await?; jvm.invoke_virtual( &this, "java/lang/AbstractStringBuilder", diff --git a/rustjava-runtime/src/classes/java/lang/boolean.rs b/rustjava-runtime/src/classes/java/lang/boolean.rs index 9313ae70..dc270fe0 100644 --- a/rustjava-runtime/src/classes/java/lang/boolean.rs +++ b/rustjava-runtime/src/classes/java/lang/boolean.rs @@ -88,7 +88,7 @@ impl Boolean { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "Z", value).await + jvm.put_field(&mut this, "java/lang/Boolean", "value", "Z", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -99,11 +99,11 @@ impl Boolean { }; let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "Z", parsed).await + jvm.put_field(&mut this, "java/lang/Boolean", "value", "Z", parsed).await } async fn boolean_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "Z").await + jvm.get_field(&this, "java/lang/Boolean", "value", "Z").await } async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef) -> Result> { diff --git a/rustjava-runtime/src/classes/java/lang/byte.rs b/rustjava-runtime/src/classes/java/lang/byte.rs index 01996f99..727b0ede 100644 --- a/rustjava-runtime/src/classes/java/lang/byte.rs +++ b/rustjava-runtime/src/classes/java/lang/byte.rs @@ -115,7 +115,7 @@ impl Byte { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i8) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "B", value).await + jvm.put_field(&mut this, "java/lang/Byte", "value", "B", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -124,7 +124,7 @@ impl Byte { .await?; let mut this = this; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "B", value).await + jvm.put_field(&mut this, "java/lang/Byte", "value", "B", value).await } async fn parse_byte(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef) -> Result { @@ -177,7 +177,7 @@ impl Byte { } async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "B").await + jvm.get_field(&this, "java/lang/Byte", "value", "B").await } async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { diff --git a/rustjava-runtime/src/classes/java/lang/character.rs b/rustjava-runtime/src/classes/java/lang/character.rs index 889ffbf9..5e074572 100644 --- a/rustjava-runtime/src/classes/java/lang/character.rs +++ b/rustjava-runtime/src/classes/java/lang/character.rs @@ -384,11 +384,11 @@ impl Character { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: JavaChar) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "C", value).await + jvm.put_field(&mut this, "java/lang/Character", "value", "C", value).await } async fn char_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "C").await + jvm.get_field(&this, "java/lang/Character", "value", "C").await } async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result> { diff --git a/rustjava-runtime/src/classes/java/lang/class.rs b/rustjava-runtime/src/classes/java/lang/class.rs index 6dfce985..dd96d176 100644 --- a/rustjava-runtime/src/classes/java/lang/class.rs +++ b/rustjava-runtime/src/classes/java/lang/class.rs @@ -224,7 +224,7 @@ impl Class { async fn get_class_loader(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.Class::getClassLoader({this:?})"); - jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await + jvm.get_field(&this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await } async fn get_component_type(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -255,7 +255,8 @@ impl Class { } else { component_descriptor }; - let defining_loader: ClassInstanceRef = jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await?; + let defining_loader: ClassInstanceRef = + jvm.get_field(&this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await?; if defining_loader.is_null() { return Ok(jvm.resolve_class(component_name).await?.java_class().into()); } @@ -301,7 +302,7 @@ impl Class { ) -> Result> { tracing::debug!("java.lang.Class::getResourceAsStream({this:?}, {name:?})"); - let class_loader: ClassInstanceRef = jvm.get_field(&this, "classLoader", "Ljava/lang/ClassLoader;").await?; + let class_loader: ClassInstanceRef = jvm.get_field(&this, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await?; let class_loader = if class_loader.is_null() { // TODO ClassLoader.getSystemResourceAsStream? diff --git a/rustjava-runtime/src/classes/java/lang/class_loader.rs b/rustjava-runtime/src/classes/java/lang/class_loader.rs index e2e3c095..98efd3b2 100644 --- a/rustjava-runtime/src/classes/java/lang/class_loader.rs +++ b/rustjava-runtime/src/classes/java/lang/class_loader.rs @@ -85,7 +85,8 @@ impl ClassLoader { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "parent", "Ljava/lang/ClassLoader;", parent).await?; + jvm.put_field(&mut this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;", parent) + .await?; Ok(()) } @@ -217,7 +218,8 @@ impl ClassLoader { (element_class_name,), ) .await?; - jvm.get_field(&element_class, "classLoader", "Ljava/lang/ClassLoader;").await? + jvm.get_field(&element_class, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;") + .await? } else { None }; @@ -228,7 +230,7 @@ impl ClassLoader { return Ok(java_class.into()); } - let parent: ClassInstanceRef = jvm.get_field(&this, "parent", "Ljava/lang/ClassLoader;").await?; + let parent: ClassInstanceRef = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?; let class: ClassInstanceRef = if !parent.is_null() { jvm.invoke_virtual( &parent, @@ -296,7 +298,7 @@ impl ClassLoader { ) -> Result> { tracing::debug!("java.lang.ClassLoader::getResource({this:?})"); - let parent: ClassInstanceRef = jvm.get_field(&this, "parent", "Ljava/lang/ClassLoader;").await?; + let parent: ClassInstanceRef = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?; let result: ClassInstanceRef = if !parent.is_null() { jvm.invoke_virtual( diff --git a/rustjava-runtime/src/classes/java/lang/double.rs b/rustjava-runtime/src/classes/java/lang/double.rs index 8f8e8a92..46a4c3e5 100644 --- a/rustjava-runtime/src/classes/java/lang/double.rs +++ b/rustjava-runtime/src/classes/java/lang/double.rs @@ -138,7 +138,7 @@ impl Double { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: f64) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "D", value).await + jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -148,7 +148,7 @@ impl Double { let value = JavaLangString::to_rust_string(jvm, &value).await?; let value = Self::parse_value(jvm, &value).await?; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "D", value).await + jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await } async fn parse_value(jvm: &Jvm, value: &str) -> Result { @@ -257,7 +257,7 @@ impl Double { } async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "D").await + jvm.get_field(&this, "java/lang/Double", "value", "D").await } fn format_value(value: f64) -> RustString { diff --git a/rustjava-runtime/src/classes/java/lang/enum.rs b/rustjava-runtime/src/classes/java/lang/enum.rs index f574c736..8b394047 100644 --- a/rustjava-runtime/src/classes/java/lang/enum.rs +++ b/rustjava-runtime/src/classes/java/lang/enum.rs @@ -77,20 +77,20 @@ impl Enum { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, name: ClassInstanceRef, ordinal: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; - jvm.put_field(&mut this, "ordinal", "I", ordinal).await + jvm.put_field(&mut this, "java/lang/Enum", "name", "Ljava/lang/String;", name).await?; + jvm.put_field(&mut this, "java/lang/Enum", "ordinal", "I", ordinal).await } async fn name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/lang/Enum", "name", "Ljava/lang/String;").await } async fn ordinal(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "ordinal", "I").await + jvm.get_field(&this, "java/lang/Enum", "ordinal", "I").await } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/lang/Enum", "name", "Ljava/lang/String;").await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -125,8 +125,8 @@ impl Enum { if this_declaring_class != other_declaring_class { return Err(jvm.exception("java/lang/ClassCastException", "enum types differ").await); } - let this_ordinal: i32 = jvm.get_field(&this, "ordinal", "I").await?; - let other_ordinal: i32 = jvm.get_field(&other, "ordinal", "I").await?; + let this_ordinal: i32 = jvm.get_field(&this, "java/lang/Enum", "ordinal", "I").await?; + let other_ordinal: i32 = jvm.get_field(&other, "java/lang/Enum", "ordinal", "I").await?; Ok(this_ordinal - other_ordinal) } diff --git a/rustjava-runtime/src/classes/java/lang/exception_in_initializer_error.rs b/rustjava-runtime/src/classes/java/lang/exception_in_initializer_error.rs index f6447502..4ab789bc 100644 --- a/rustjava-runtime/src/classes/java/lang/exception_in_initializer_error.rs +++ b/rustjava-runtime/src/classes/java/lang/exception_in_initializer_error.rs @@ -53,7 +53,14 @@ impl ExceptionInInitializerError { // unlike Throwable(Throwable), this keeps detailMessage null so toString is just the class name let _: () = jvm.invoke_special(&this, "java/lang/LinkageError", "", "()V", ()).await?; - jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?; + jvm.put_field( + &mut this, + "java/lang/ExceptionInInitializerError", + "cause", + "Ljava/lang/Throwable;", + cause, + ) + .await?; Ok(()) } @@ -61,6 +68,7 @@ impl ExceptionInInitializerError { async fn get_exception(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.ExceptionInInitializerError::getException({this:?})"); - jvm.get_field(&this, "cause", "Ljava/lang/Throwable;").await + jvm.get_field(&this, "java/lang/ExceptionInInitializerError", "cause", "Ljava/lang/Throwable;") + .await } } diff --git a/rustjava-runtime/src/classes/java/lang/float.rs b/rustjava-runtime/src/classes/java/lang/float.rs index fd509c6e..54f22b7b 100644 --- a/rustjava-runtime/src/classes/java/lang/float.rs +++ b/rustjava-runtime/src/classes/java/lang/float.rs @@ -139,12 +139,12 @@ impl Float { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: f32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "F", value).await + jvm.put_field(&mut this, "java/lang/Float", "value", "F", value).await } async fn init_double(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: f64) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "F", value as f32).await + jvm.put_field(&mut this, "java/lang/Float", "value", "F", value as f32).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -154,7 +154,7 @@ impl Float { let value = JavaLangString::to_rust_string(jvm, &value).await?; let value = Self::parse_value(jvm, &value).await?; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "F", value).await + jvm.put_field(&mut this, "java/lang/Float", "value", "F", value).await } async fn parse_value(jvm: &Jvm, value: &str) -> Result { @@ -258,7 +258,7 @@ impl Float { } async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "F").await + jvm.get_field(&this, "java/lang/Float", "value", "F").await } async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { diff --git a/rustjava-runtime/src/classes/java/lang/integer.rs b/rustjava-runtime/src/classes/java/lang/integer.rs index eda4b485..8302e63a 100644 --- a/rustjava-runtime/src/classes/java/lang/integer.rs +++ b/rustjava-runtime/src/classes/java/lang/integer.rs @@ -155,7 +155,7 @@ impl Integer { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "I", value).await + jvm.put_field(&mut this, "java/lang/Integer", "value", "I", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -166,7 +166,7 @@ impl Integer { let value = Self::parse_value(jvm, &value, 10).await?; let mut this = this; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "I", value).await + jvm.put_field(&mut this, "java/lang/Integer", "value", "I", value).await } fn parse_value_raw(value: &str, radix: u32) -> Option { @@ -337,7 +337,7 @@ impl Integer { } async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "I").await + jvm.get_field(&this, "java/lang/Integer", "value", "I").await } async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { @@ -417,7 +417,7 @@ impl Integer { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "I").await + jvm.get_field(&this, "java/lang/Integer", "value", "I").await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { diff --git a/rustjava-runtime/src/classes/java/lang/long.rs b/rustjava-runtime/src/classes/java/lang/long.rs index 7d938501..de6112cb 100644 --- a/rustjava-runtime/src/classes/java/lang/long.rs +++ b/rustjava-runtime/src/classes/java/lang/long.rs @@ -156,7 +156,7 @@ impl Long { } async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i64) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "J", value).await + jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { let value: i64 = jvm @@ -164,7 +164,7 @@ impl Long { .await?; let mut this = this; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "J", value).await + jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await } fn parse_raw(value: &str, radix: u32) -> Option { if !(2..=36).contains(&radix) || value.is_empty() { @@ -317,22 +317,22 @@ impl Long { } } async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "J").await? as i8) + Ok(jvm.get_field::(&this, "java/lang/Long", "value", "J").await? as i8) } async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "J").await? as i16) + Ok(jvm.get_field::(&this, "java/lang/Long", "value", "J").await? as i16) } async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "J").await? as i32) + Ok(jvm.get_field::(&this, "java/lang/Long", "value", "J").await? as i32) } async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "J").await + jvm.get_field(&this, "java/lang/Long", "value", "J").await } async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "J").await? as f32) + Ok(jvm.get_field::(&this, "java/lang/Long", "value", "J").await? as f32) } async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "J").await? as f64) + Ok(jvm.get_field::(&this, "java/lang/Long", "value", "J").await? as f64) } fn format_value(value: i64, radix: u32) -> RustString { let radix = if (2..=36).contains(&radix) { radix } else { 10 }; diff --git a/rustjava-runtime/src/classes/java/lang/short.rs b/rustjava-runtime/src/classes/java/lang/short.rs index 6a2bce2c..520cbbd3 100644 --- a/rustjava-runtime/src/classes/java/lang/short.rs +++ b/rustjava-runtime/src/classes/java/lang/short.rs @@ -115,7 +115,7 @@ impl Short { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i16) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "S", value).await + jvm.put_field(&mut this, "java/lang/Short", "value", "S", value).await } async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result<()> { @@ -124,7 +124,7 @@ impl Short { .await?; let mut this = this; let _: () = jvm.invoke_special(&this, "java/lang/Number", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "S", value).await + jvm.put_field(&mut this, "java/lang/Short", "value", "S", value).await } async fn parse_short(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef) -> Result { @@ -177,22 +177,22 @@ impl Short { } async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok((jvm.get_field::(&this, "value", "S").await?) as i8) + Ok((jvm.get_field::(&this, "java/lang/Short", "value", "S").await?) as i8) } async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "value", "S").await + jvm.get_field(&this, "java/lang/Short", "value", "S").await } async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "S").await? as i32) + Ok(jvm.get_field::(&this, "java/lang/Short", "value", "S").await? as i32) } async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "S").await? as i64) + Ok(jvm.get_field::(&this, "java/lang/Short", "value", "S").await? as i64) } async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "S").await? as f32) + Ok(jvm.get_field::(&this, "java/lang/Short", "value", "S").await? as f32) } async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "S").await? as f64) + Ok(jvm.get_field::(&this, "java/lang/Short", "value", "S").await? as f64) } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -203,7 +203,7 @@ impl Short { Ok(JavaLangString::from_rust_string(jvm, &format!("{value}")).await?.into()) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "value", "S").await? as i32) + Ok(jvm.get_field::(&this, "java/lang/Short", "value", "S").await? as i32) } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { if other.is_null() || !jvm.is_instance(&**other, "java/lang/Short") { diff --git a/rustjava-runtime/src/classes/java/lang/string.rs b/rustjava-runtime/src/classes/java/lang/string.rs index 7ab09ba1..6cfd1355 100644 --- a/rustjava-runtime/src/classes/java/lang/string.rs +++ b/rustjava-runtime/src/classes/java/lang/string.rs @@ -240,9 +240,9 @@ impl String { } async fn value_range(jvm: &Jvm, this: &ClassInstanceRef) -> Result<(ClassInstanceRef>, usize, usize)> { - let value = jvm.get_field(this, "value", "[C").await?; - let offset: i32 = jvm.get_field(this, "offset", "I").await?; - let count: i32 = jvm.get_field(this, "count", "I").await?; + let value = jvm.get_field(this, "java/lang/String", "value", "[C").await?; + let offset: i32 = jvm.get_field(this, "java/lang/String", "offset", "I").await?; + let count: i32 = jvm.get_field(this, "java/lang/String", "count", "I").await?; // access flags are not enforced, so bytecode can leave a negative here, which would widen into a huge usize if offset < 0 || count < 0 { @@ -312,9 +312,9 @@ impl String { let data: Vec = jvm.load_array(&value, offset as _, count as _).await?; jvm.store_array(&mut array, 0, data).await?; - jvm.put_field(&mut this, "value", "[C", array).await?; - jvm.put_field(&mut this, "offset", "I", 0).await?; - jvm.put_field(&mut this, "count", "I", count).await?; + jvm.put_field(&mut this, "java/lang/String", "value", "[C", array).await?; + jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?; + jvm.put_field(&mut this, "java/lang/String", "count", "I", count).await?; Ok(()) } @@ -346,9 +346,9 @@ impl String { .await); } - jvm.put_field(&mut this, "value", "[C", value).await?; - jvm.put_field(&mut this, "offset", "I", offset).await?; - jvm.put_field(&mut this, "count", "I", count).await?; + jvm.put_field(&mut this, "java/lang/String", "value", "[C", value).await?; + jvm.put_field(&mut this, "java/lang/String", "offset", "I", offset).await?; + jvm.put_field(&mut this, "java/lang/String", "count", "I", count).await?; Ok(()) } @@ -434,8 +434,8 @@ impl String { return Ok(true); } - let this_count: i32 = jvm.get_field(&this, "count", "I").await?; - let other_count: i32 = jvm.get_field(&other, "count", "I").await?; + let this_count: i32 = jvm.get_field(&this, "java/lang/String", "count", "I").await?; + let other_count: i32 = jvm.get_field(&other, "java/lang/String", "count", "I").await?; if this_count != other_count { return Ok(false); } @@ -613,7 +613,7 @@ impl String { async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.String::length({this:?})"); - jvm.get_field(&this, "count", "I").await + jvm.get_field(&this, "java/lang/String", "count", "I").await } async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, begin_index: i32) -> Result> { @@ -868,9 +868,9 @@ impl String { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let array = jvm.instantiate_array("C", 0).await?; - jvm.put_field(&mut this, "value", "[C", array).await?; - jvm.put_field(&mut this, "offset", "I", 0).await?; - jvm.put_field(&mut this, "count", "I", 0).await?; + jvm.put_field(&mut this, "java/lang/String", "value", "[C", array).await?; + jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?; + jvm.put_field(&mut this, "java/lang/String", "count", "I", 0).await?; Ok(()) } @@ -1293,7 +1293,7 @@ impl String { async fn last_index_of_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, str: ClassInstanceRef) -> Result { tracing::debug!("java.lang.String::lastIndexOf({this:?}, {str:?})"); - let length: i32 = jvm.get_field(&this, "count", "I").await?; + let length: i32 = jvm.get_field(&this, "java/lang/String", "count", "I").await?; jvm.invoke_virtual(&this, "java/lang/String", "lastIndexOf", "(Ljava/lang/String;I)I", (str, length)) .await } diff --git a/rustjava-runtime/src/classes/java/lang/string_buffer.rs b/rustjava-runtime/src/classes/java/lang/string_buffer.rs index 58fdc7cf..2239c367 100644 --- a/rustjava-runtime/src/classes/java/lang/string_buffer.rs +++ b/rustjava-runtime/src/classes/java/lang/string_buffer.rs @@ -958,7 +958,7 @@ impl StringBuffer { ) -> Result> { tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {array:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if offset < 0 || offset > count { return Err(jvm .exception( @@ -1066,7 +1066,7 @@ impl StringBuffer { async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, start: i32, end: i32) -> Result> { tracing::debug!("java.lang.StringBuffer::delete({this:?}, {start}, {end})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; let end = end.min(count); if start < 0 || start > end { return Err(jvm @@ -1078,10 +1078,11 @@ impl StringBuffer { } if start != end { - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; let tail: Vec = jvm.load_array(&value, end as usize, (count - end) as usize).await?; jvm.store_array(&mut value, start as usize, tail).await?; - jvm.put_field(&mut this, "count", "I", count - (end - start)).await?; + jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - (end - start)) + .await?; } Ok(this) } @@ -1089,7 +1090,7 @@ impl StringBuffer { async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result> { tracing::debug!("java.lang.StringBuffer::deleteCharAt({this:?}, {index})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if index < 0 || index >= count { return Err(jvm .exception( @@ -1099,10 +1100,10 @@ impl StringBuffer { .await); } - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; let tail: Vec = jvm.load_array(&value, (index + 1) as usize, (count - index - 1) as usize).await?; jvm.store_array(&mut value, index as usize, tail).await?; - jvm.put_field(&mut this, "count", "I", count - 1).await?; + jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - 1).await?; Ok(this) } @@ -1116,7 +1117,7 @@ impl StringBuffer { ) -> Result> { tracing::debug!("java.lang.StringBuffer::replace({this:?}, {start}, {end}, {string:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; let end = end.min(count); if start < 0 || start > count || start > end { return Err(jvm @@ -1135,18 +1136,18 @@ impl StringBuffer { let new_count = count + replacement_length - (end - start); Self::expand_capacity(jvm, &mut this, new_count).await?; - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; let tail: Vec = jvm.load_array(&value, end as usize, (count - end) as usize).await?; jvm.store_array(&mut value, (start + replacement_length) as usize, tail).await?; jvm.store_array(&mut value, start as usize, replacement).await?; - jvm.put_field(&mut this, "count", "I", new_count).await?; + jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_count).await?; Ok(this) } async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, start: i32) -> Result> { tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, count)) .await } @@ -1160,7 +1161,7 @@ impl StringBuffer { ) -> Result> { tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start}, {end})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if start < 0 || end > count || start > end { return Err(jvm .exception( @@ -1170,7 +1171,7 @@ impl StringBuffer { .await); } - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; Ok(jvm.new_class("java/lang/String", "([CII)V", (value, start, end - start)).await?.into()) } @@ -1190,8 +1191,8 @@ impl StringBuffer { async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.StringBuffer::reverse({this:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; let mut chars: Vec = jvm.load_array(&value, 0, count as usize).await?; chars.reverse(); jvm.store_array(&mut value, 0, chars).await?; @@ -1251,8 +1252,8 @@ impl StringBuffer { async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.StringBuffer::toString({this:?})"); - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; // the buffer stays mutable, so snapshot it instead of handing it to the sharing constructor let chars: Vec = jvm.load_array(&value, 0, count as usize).await?; @@ -1263,7 +1264,7 @@ impl StringBuffer { async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.StringBuffer::capacity({this:?})"); - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; Ok(jvm.array_length(&value).await? as i32) } @@ -1288,27 +1289,27 @@ impl StringBuffer { return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await); } - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if new_length > count { Self::expand_capacity(jvm, &mut this, new_length).await?; - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; jvm.store_array(&mut value, count as usize, vec![0 as JavaChar; (new_length - count) as usize]) .await?; } - jvm.put_field(&mut this, "count", "I", new_length).await?; + jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_length).await?; Ok(()) } async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.StringBuffer::length({this:?})"); - jvm.get_field(&this, "count", "I").await + jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await } async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result { tracing::debug!("java.lang.StringBuffer::charAt({this:?}, {index})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if index < 0 || index >= count { return Err(jvm .exception( @@ -1318,7 +1319,7 @@ impl StringBuffer { .await); } - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; Ok(jvm.load_array(&value, index as usize, 1).await?[0]) } @@ -1345,7 +1346,7 @@ impl StringBuffer { async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32, character: JavaChar) -> Result<()> { tracing::debug!("java.lang.StringBuffer::setCharAt({this:?}, {index}, {character})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if index < 0 || index >= count { return Err(jvm .exception( @@ -1355,7 +1356,7 @@ impl StringBuffer { .await); } - let mut value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; jvm.store_array(&mut value, index as usize, [character]).await } @@ -1370,7 +1371,7 @@ impl StringBuffer { ) -> Result<()> { tracing::debug!("java.lang.StringBuffer::getChars({this:?}, {src_begin}, {src_end}, {destination:?}, {dst_begin})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?; if src_begin < 0 || src_end > count || src_begin > src_end { return Err(jvm .exception( @@ -1394,38 +1395,38 @@ impl StringBuffer { .await); } - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?; let chars: Vec = jvm.load_array(&value, src_begin as usize, copy_length as usize).await?; jvm.store_array(&mut destination, dst_begin as usize, chars).await } async fn expand_capacity(jvm: &Jvm, this: &mut ClassInstanceRef, minimum_capacity: i32) -> Result<()> { - let value: ClassInstanceRef> = jvm.get_field(this, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?; let old_capacity = jvm.array_length(&value).await? as i32; if minimum_capacity <= old_capacity { return Ok(()); } let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2)); - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?; let chars: Vec = jvm.load_array(&value, 0, count as usize).await?; let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?; jvm.store_array(&mut new_value, 0, chars).await?; - jvm.put_field(this, "value", "[C", new_value).await + jvm.put_field(this, "java/lang/StringBuffer", "value", "[C", new_value).await } async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef, chars: Vec) -> Result<()> { - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?; let new_count = count + chars.len() as i32; Self::expand_capacity(jvm, this, new_count).await?; - let mut value: ClassInstanceRef> = jvm.get_field(this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?; jvm.store_array(&mut value, count as usize, chars).await?; - jvm.put_field(this, "count", "I", new_count).await + jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await } async fn insert_utf16(jvm: &Jvm, this: &mut ClassInstanceRef, offset: i32, chars: Vec) -> Result<()> { - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?; if offset < 0 || offset > count { return Err(jvm .exception( @@ -1438,10 +1439,10 @@ impl StringBuffer { let inserted_length = chars.len() as i32; let new_count = count + inserted_length; Self::expand_capacity(jvm, this, new_count).await?; - let mut value: ClassInstanceRef> = jvm.get_field(this, "value", "[C").await?; + let mut value: ClassInstanceRef> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?; let tail: Vec = jvm.load_array(&value, offset as usize, (count - offset) as usize).await?; jvm.store_array(&mut value, (offset + inserted_length) as usize, tail).await?; jvm.store_array(&mut value, offset as usize, chars).await?; - jvm.put_field(this, "count", "I", new_count).await + jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await } } diff --git a/rustjava-runtime/src/classes/java/lang/string_builder.rs b/rustjava-runtime/src/classes/java/lang/string_builder.rs index a7ea4d48..1020dada 100644 --- a/rustjava-runtime/src/classes/java/lang/string_builder.rs +++ b/rustjava-runtime/src/classes/java/lang/string_builder.rs @@ -966,8 +966,8 @@ impl StringBuilder { } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let value: ClassInstanceRef> = jvm.get_field(&this, "value", "[C").await?; + let count: i32 = jvm.get_field(&this, "java/lang/StringBuilder", "count", "I").await?; + let value: ClassInstanceRef> = jvm.get_field(&this, "java/lang/StringBuilder", "value", "[C").await?; Ok(JavaLangString::from_utf16(jvm, jvm.load_array(&value, 0, count as usize).await?) .await? .into()) diff --git a/rustjava-runtime/src/classes/java/lang/thread.rs b/rustjava-runtime/src/classes/java/lang/thread.rs index 1b4f0dbc..9d1c9298 100644 --- a/rustjava-runtime/src/classes/java/lang/thread.rs +++ b/rustjava-runtime/src/classes/java/lang/thread.rs @@ -219,15 +219,16 @@ impl Thread { } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "target", "Ljava/lang/Runnable;", target).await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; - jvm.put_field(&mut this, "priority", "I", 5i32).await?; - jvm.put_field(&mut this, "interrupted", "Z", false).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "alive", "Z", false).await?; + jvm.put_field(&mut this, "java/lang/Thread", "target", "Ljava/lang/Runnable;", target) + .await?; + jvm.put_field(&mut this, "java/lang/Thread", "name", "Ljava/lang/String;", name).await?; + jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", 5i32).await?; + jvm.put_field(&mut this, "java/lang/Thread", "interrupted", "Z", false).await?; + jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", false).await?; + jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", false).await?; let current_thread = jvm.current_java_thread(); - let daemon: bool = jvm.get_field(¤t_thread, "daemon", "Z").await?; - jvm.put_field(&mut this, "daemon", "Z", daemon).await?; + let daemon: bool = jvm.get_field(¤t_thread, "java/lang/Thread", "daemon", "Z").await?; + jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", daemon).await?; Ok(()) } @@ -236,12 +237,12 @@ impl Thread { tracing::debug!("java.lang.Thread::({this:?}, {internal:?})"); let id = context.current_task_id(); - jvm.put_field(&mut this, "id", "J", id as i64).await?; - jvm.put_field(&mut this, "priority", "I", 5i32).await?; - jvm.put_field(&mut this, "interrupted", "Z", false).await?; - jvm.put_field(&mut this, "started", "Z", true).await?; - jvm.put_field(&mut this, "alive", "Z", internal).await?; - jvm.put_field(&mut this, "daemon", "Z", false).await?; + jvm.put_field(&mut this, "java/lang/Thread", "id", "J", id as i64).await?; + jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", 5i32).await?; + jvm.put_field(&mut this, "java/lang/Thread", "interrupted", "Z", false).await?; + jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", true).await?; + jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", internal).await?; + jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", false).await?; Ok(()) } @@ -249,7 +250,7 @@ impl Thread { async fn start(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.lang.Thread::start({this:?})"); - let started: bool = jvm.get_field(&this, "started", "Z").await?; + let started: bool = jvm.get_field(&this, "java/lang/Thread", "started", "Z").await?; if started { return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread already started").await); } @@ -305,7 +306,7 @@ impl Thread { let cleanup = if let Err(error) = self.jvm.monitor_enter(&self.this).await { Err(error) } else { - let alive_result = self.jvm.put_field(&mut this, "alive", "Z", false).await; + let alive_result = self.jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", false).await; let notify_result = if alive_result.is_ok() { self.jvm.object_notify(&self.this, usize::MAX).await } else { @@ -323,8 +324,8 @@ impl Thread { } } - jvm.put_field(&mut this, "started", "Z", true).await?; - jvm.put_field(&mut this, "alive", "Z", true).await?; + jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", true).await?; + jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", true).await?; let id: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?; @@ -347,7 +348,7 @@ impl Thread { async fn run(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.lang.Thread::run({this:?})"); - let target: ClassInstanceRef = jvm.get_field(&this, "target", "Ljava/lang/Runnable;").await?; + let target: ClassInstanceRef = jvm.get_field(&this, "java/lang/Thread", "target", "Ljava/lang/Runnable;").await?; if !target.is_null() { let _: () = jvm.invoke_virtual(&target, &target.class_definition().name(), "run", "()V", ()).await?; } @@ -372,7 +373,7 @@ impl Thread { let start = context.now(); loop { - let alive: bool = jvm.get_field(&this, "alive", "Z").await?; + let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?; if !alive { return Ok(()); } @@ -393,14 +394,14 @@ impl Thread { async fn is_alive(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.Thread::isAlive({this:?})"); - let alive: bool = jvm.get_field(&this, "alive", "Z").await?; + let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?; Ok(alive) } async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.Thread::getName({this:?})"); - let name: ClassInstanceRef = jvm.get_field(&this, "name", "Ljava/lang/String;").await?; + let name: ClassInstanceRef = jvm.get_field(&this, "java/lang/Thread", "name", "Ljava/lang/String;").await?; if name.is_null() { return Ok(JavaLangString::from_rust_string(jvm, "main").await?.into()); } @@ -415,12 +416,12 @@ impl Thread { return Err(jvm.exception("java/lang/NullPointerException", "name").await); } - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await + jvm.put_field(&mut this, "java/lang/Thread", "name", "Ljava/lang/String;", name).await } async fn get_priority(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.Thread::getPriority({this:?})"); - jvm.get_field(&this, "priority", "I").await + jvm.get_field(&this, "java/lang/Thread", "priority", "I").await } async fn interrupt(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { @@ -449,7 +450,7 @@ impl Thread { .invoke_virtual(&this, "java/lang/Thread", "getName", "()Ljava/lang/String;", ()) .await?; let name = JavaLangString::to_rust_string(jvm, &name).await?; - let priority: i32 = jvm.get_field(&this, "priority", "I").await?; + let priority: i32 = jvm.get_field(&this, "java/lang/Thread", "priority", "I").await?; Ok(JavaLangString::from_rust_string(jvm, &format!("Thread[{name},{priority}]")).await?.into()) } @@ -477,7 +478,7 @@ impl Thread { return Err(jvm.exception("java/lang/IllegalArgumentException", "priority out of range").await); } - jvm.put_field(&mut this, "priority", "I", new_priority).await?; + jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", new_priority).await?; Ok(()) } @@ -485,17 +486,17 @@ impl Thread { async fn set_daemon(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, daemon: bool) -> Result<()> { tracing::debug!("java.lang.Thread::setDaemon({this:?}, {daemon:?})"); - let alive: bool = jvm.get_field(&this, "alive", "Z").await?; + let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?; if alive { return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread is active").await); } - jvm.put_field(&mut this, "daemon", "Z", daemon).await + jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", daemon).await } async fn is_daemon(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.lang.Thread::isDaemon({this:?})"); - jvm.get_field(&this, "daemon", "Z").await + jvm.get_field(&this, "java/lang/Thread", "daemon", "Z").await } async fn current_thread(jvm: &Jvm, _: &mut RuntimeContext) -> Result> { diff --git a/rustjava-runtime/src/classes/java/lang/throwable.rs b/rustjava-runtime/src/classes/java/lang/throwable.rs index 9b7d2502..4462bcfc 100644 --- a/rustjava-runtime/src/classes/java/lang/throwable.rs +++ b/rustjava-runtime/src/classes/java/lang/throwable.rs @@ -97,7 +97,8 @@ impl Throwable { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?; + jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message) + .await?; let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ()) @@ -117,8 +118,10 @@ impl Throwable { jvm.invoke_virtual(&cause, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await? }; - jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?; - jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?; + jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message) + .await?; + jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause) + .await?; let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ()) @@ -138,8 +141,10 @@ impl Throwable { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?; - jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?; + jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message) + .await?; + jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause) + .await?; let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ()) @@ -151,13 +156,13 @@ impl Throwable { async fn get_cause(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.Throwable::getCause({this:?})"); - jvm.get_field(&this, "cause", "Ljava/lang/Throwable;").await + jvm.get_field(&this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;").await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.lang.Throwable::getMessage({this:?})"); - jvm.get_field(&this, "detailMessage", "Ljava/lang/String;").await + jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await } async fn get_localized_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -175,7 +180,8 @@ impl Throwable { ) -> Result> { tracing::debug!("java.lang.Throwable::initCause({this:?}, {cause:?})"); - jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?; + jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause) + .await?; Ok(this) } @@ -189,7 +195,8 @@ impl Throwable { let java_line = JavaLangString::from_rust_string(jvm, line).await?; jvm.store_array(&mut stack_trace_array, i, core::iter::once(java_line)).await?; } - jvm.put_field(&mut this, "stackTrace", "[Ljava/lang/String;", stack_trace_array).await?; + jvm.put_field(&mut this, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;", stack_trace_array) + .await?; Ok(this) } @@ -242,7 +249,7 @@ impl Throwable { .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ()) .await?; - let message: ClassInstanceRef = jvm.get_field(&this, "detailMessage", "Ljava/lang/String;").await?; + let message: ClassInstanceRef = jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await?; let class_name = JavaLangString::to_rust_string(jvm, &class_name).await?; let message = if message.is_null() { @@ -287,7 +294,9 @@ impl Throwable { ) .await?; - let stack_trace: ClassInstanceRef>> = jvm.get_field(¤t, "stackTrace", "[Ljava/lang/String;").await?; + let stack_trace: ClassInstanceRef>> = jvm + .get_field(¤t, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;") + .await?; if !stack_trace.is_null() { let length = jvm.array_length(&stack_trace).await?; let lines: Vec> = jvm.load_array(&stack_trace, 0, length).await?; diff --git a/rustjava-runtime/src/classes/java/net/jar_url_connection.rs b/rustjava-runtime/src/classes/java/net/jar_url_connection.rs index 1b6b950b..3f741b6e 100644 --- a/rustjava-runtime/src/classes/java/net/jar_url_connection.rs +++ b/rustjava-runtime/src/classes/java/net/jar_url_connection.rs @@ -57,10 +57,12 @@ impl JarURLConnection { let file_url = JavaLangString::from_rust_string(jvm, split[0]).await?; let file_url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (file_url,)).await?; - jvm.put_field(&mut this, "fileUrl", "Ljava/net/URL;", file_url).await?; + jvm.put_field(&mut this, "java/net/JarURLConnection", "fileUrl", "Ljava/net/URL;", file_url) + .await?; let entry = JavaLangString::from_rust_string(jvm, split[1]).await?; - jvm.put_field(&mut this, "entry", "Ljava/lang/String;", entry).await?; + jvm.put_field(&mut this, "java/net/JarURLConnection", "entry", "Ljava/lang/String;", entry) + .await?; Ok(()) } @@ -68,7 +70,7 @@ impl JarURLConnection { async fn get_entry_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.JarURLConnection::getEntryName({this:?})"); - let entry = jvm.get_field(&this, "entry", "Ljava/lang/String;").await?; + let entry = jvm.get_field(&this, "java/net/JarURLConnection", "entry", "Ljava/lang/String;").await?; Ok(entry) } @@ -76,7 +78,7 @@ impl JarURLConnection { async fn get_jar_file_url(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.JarURLConnection::getJarFileURL({this:?})"); - let file_url = jvm.get_field(&this, "fileUrl", "Ljava/net/URL;").await?; + let file_url = jvm.get_field(&this, "java/net/JarURLConnection", "fileUrl", "Ljava/net/URL;").await?; Ok(file_url) } diff --git a/rustjava-runtime/src/classes/java/net/url.rs b/rustjava-runtime/src/classes/java/net/url.rs index cd21bde8..773b7c77 100644 --- a/rustjava-runtime/src/classes/java/net/url.rs +++ b/rustjava-runtime/src/classes/java/net/url.rs @@ -132,7 +132,7 @@ impl URL { let handler = Self::get_handler(jvm, protocol).await?; - jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler.clone()) + jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone()) .await?; let _: () = jvm @@ -186,7 +186,7 @@ impl URL { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler.clone()) + jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone()) .await?; let _: () = jvm @@ -203,7 +203,8 @@ impl URL { let protocol = JavaLangString::to_rust_string(jvm, &protocol).await?; let handler = Self::get_handler(jvm, &protocol).await?; - jvm.put_field(&mut this, "handler", "Ljava/net/URLStreamHandler;", handler).await?; + jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler) + .await?; } Ok(()) @@ -222,10 +223,11 @@ impl URL { ) -> Result<()> { tracing::debug!("java.net.URL::set({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})", &r#ref); - jvm.put_field(&mut this, "protocol", "Ljava/lang/String;", protocol).await?; - jvm.put_field(&mut this, "host", "Ljava/lang/String;", host).await?; - jvm.put_field(&mut this, "port", "I", port).await?; - jvm.put_field(&mut this, "file", "Ljava/lang/String;", file).await?; + jvm.put_field(&mut this, "java/net/URL", "protocol", "Ljava/lang/String;", protocol) + .await?; + jvm.put_field(&mut this, "java/net/URL", "host", "Ljava/lang/String;", host).await?; + jvm.put_field(&mut this, "java/net/URL", "port", "I", port).await?; + jvm.put_field(&mut this, "java/net/URL", "file", "Ljava/lang/String;", file).await?; Ok(()) } @@ -233,7 +235,7 @@ impl URL { async fn open_connection(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.URL::openConnection({this:?})"); - let handler = jvm.get_field(&this, "handler", "Ljava/net/URLStreamHandler;").await?; + let handler = jvm.get_field(&this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;").await?; let connection = jvm .invoke_virtual( &handler, @@ -264,7 +266,7 @@ impl URL { async fn get_port(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.net.URL::getPort({this:?})"); - let port = jvm.get_field(&this, "port", "I").await?; + let port = jvm.get_field(&this, "java/net/URL", "port", "I").await?; Ok(port) } @@ -272,7 +274,7 @@ impl URL { async fn get_protocol(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.URL::getProtocol({this:?})"); - let protocol = jvm.get_field(&this, "protocol", "Ljava/lang/String;").await?; + let protocol = jvm.get_field(&this, "java/net/URL", "protocol", "Ljava/lang/String;").await?; Ok(protocol) } @@ -280,7 +282,7 @@ impl URL { async fn get_host(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.URL::getHost({this:?})"); - let host = jvm.get_field(&this, "host", "Ljava/lang/String;").await?; + let host = jvm.get_field(&this, "java/net/URL", "host", "Ljava/lang/String;").await?; Ok(host) } @@ -288,7 +290,7 @@ impl URL { async fn get_file(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.net.URL::getFile({this:?})"); - let file = jvm.get_field(&this, "file", "Ljava/lang/String;").await?; + let file = jvm.get_field(&this, "java/net/URL", "file", "Ljava/lang/String;").await?; Ok(file) } diff --git a/rustjava-runtime/src/classes/java/net/url_class_loader.rs b/rustjava-runtime/src/classes/java/net/url_class_loader.rs index a1978e95..0fb64854 100644 --- a/rustjava-runtime/src/classes/java/net/url_class_loader.rs +++ b/rustjava-runtime/src/classes/java/net/url_class_loader.rs @@ -63,7 +63,8 @@ impl URLClassLoader { .invoke_special(&this, "java/lang/ClassLoader", "", "(Ljava/lang/ClassLoader;)V", (parent,)) .await?; - jvm.put_field(&mut this, "urls", "[Ljava/net/URL;", urls).await?; + jvm.put_field(&mut this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;", urls) + .await?; Ok(()) } @@ -126,7 +127,7 @@ impl URLClassLoader { let name_str = JavaLangString::to_rust_string(jvm, &name).await?; - let urls = jvm.get_field(&this, "urls", "[Ljava/net/URL;").await?; + let urls = jvm.get_field(&this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;").await?; let urls: Vec> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?; for url in urls { diff --git a/rustjava-runtime/src/classes/java/text/date_format.rs b/rustjava-runtime/src/classes/java/text/date_format.rs index 14c1c450..c1dbdf01 100644 --- a/rustjava-runtime/src/classes/java/text/date_format.rs +++ b/rustjava-runtime/src/classes/java/text/date_format.rs @@ -294,8 +294,16 @@ impl DateFormat { let number_format: ClassInstanceRef = jvm .invoke_static("java/text/NumberFormat", "getInstance", "()Ljava/text/NumberFormat;", ()) .await?; - jvm.put_field(&mut this, "calendar", "Ljava/util/Calendar;", calendar).await?; - jvm.put_field(&mut this, "numberFormat", "Ljava/text/NumberFormat;", number_format).await + jvm.put_field(&mut this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;", calendar) + .await?; + jvm.put_field( + &mut this, + "java/text/DateFormat", + "numberFormat", + "Ljava/text/NumberFormat;", + number_format, + ) + .await } async fn format_object( @@ -519,18 +527,20 @@ impl DateFormat { } async fn get_calendar(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await + jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await } async fn set_calendar(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, calendar: ClassInstanceRef) -> Result<()> { if calendar.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "calendar").await); } - jvm.put_field(&mut this, "calendar", "Ljava/util/Calendar;", calendar).await + jvm.put_field(&mut this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;", calendar) + .await } async fn get_number_format(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "numberFormat", "Ljava/text/NumberFormat;").await + jvm.get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;") + .await } async fn set_number_format( @@ -542,48 +552,71 @@ impl DateFormat { if number_format.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "numberFormat").await); } - jvm.put_field(&mut this, "numberFormat", "Ljava/text/NumberFormat;", number_format).await + jvm.put_field( + &mut this, + "java/text/DateFormat", + "numberFormat", + "Ljava/text/NumberFormat;", + number_format, + ) + .await } async fn get_time_zone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await?; jvm.invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ()) .await } async fn set_time_zone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, time_zone: ClassInstanceRef) -> Result<()> { - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await?; jvm.invoke_virtual(&calendar, "java/util/Calendar", "setTimeZone", "(Ljava/util/TimeZone;)V", (time_zone,)) .await } async fn is_lenient(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await?; jvm.invoke_virtual(&calendar, "java/util/Calendar", "isLenient", "()Z", ()).await } async fn set_lenient(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, lenient: bool) -> Result<()> { - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await?; jvm.invoke_virtual(&calendar, "java/util/Calendar", "setLenient", "(Z)V", (lenient,)) .await } async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; - let number_format: ClassInstanceRef = jvm.get_field(&this, "numberFormat", "Ljava/text/NumberFormat;").await?; + let calendar: ClassInstanceRef = jvm.get_field(&this, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;").await?; + let number_format: ClassInstanceRef = jvm + .get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;") + .await?; let mut cloned: ClassInstanceRef = jvm.shallow_clone(&this)?.into(); let mut cloned_calendar: ClassInstanceRef = jvm.shallow_clone(&calendar)?.into(); - let fields: ClassInstanceRef> = jvm.get_field(&calendar, "fields", "[I").await?; + let fields: ClassInstanceRef> = jvm.get_field(&calendar, "java/util/Calendar", "fields", "[I").await?; let cloned_fields: ClassInstanceRef> = jvm.shallow_clone(&fields)?.into(); - let time_zone: ClassInstanceRef = jvm.get_field(&calendar, "timeZone", "Ljava/util/TimeZone;").await?; + let time_zone: ClassInstanceRef = jvm.get_field(&calendar, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?; let cloned_time_zone: ClassInstanceRef = jvm.shallow_clone(&time_zone)?.into(); - jvm.put_field(&mut cloned_calendar, "fields", "[I", cloned_fields).await?; - jvm.put_field(&mut cloned_calendar, "timeZone", "Ljava/util/TimeZone;", cloned_time_zone) + jvm.put_field(&mut cloned_calendar, "java/util/Calendar", "fields", "[I", cloned_fields) .await?; + jvm.put_field( + &mut cloned_calendar, + "java/util/Calendar", + "timeZone", + "Ljava/util/TimeZone;", + cloned_time_zone, + ) + .await?; let cloned_number_format: ClassInstanceRef = jvm.shallow_clone(&number_format)?.into(); - jvm.put_field(&mut cloned, "calendar", "Ljava/util/Calendar;", cloned_calendar).await?; - jvm.put_field(&mut cloned, "numberFormat", "Ljava/text/NumberFormat;", cloned_number_format) + jvm.put_field(&mut cloned, "java/text/DateFormat", "calendar", "Ljava/util/Calendar;", cloned_calendar) .await?; + jvm.put_field( + &mut cloned, + "java/text/DateFormat", + "numberFormat", + "Ljava/text/NumberFormat;", + cloned_number_format, + ) + .await?; Ok(ClassInstanceRef::new(cloned.instance)) } } diff --git a/rustjava-runtime/src/classes/java/text/decimal_format.rs b/rustjava-runtime/src/classes/java/text/decimal_format.rs index 915c0837..e8967d56 100644 --- a/rustjava-runtime/src/classes/java/text/decimal_format.rs +++ b/rustjava-runtime/src/classes/java/text/decimal_format.rs @@ -263,21 +263,72 @@ impl DecimalFormat { let positive_suffix = JavaLangString::from_rust_string(jvm, &parsed.positive_suffix).await?; let negative_prefix = JavaLangString::from_rust_string(jvm, &parsed.negative_prefix).await?; let negative_suffix = JavaLangString::from_rust_string(jvm, &parsed.negative_suffix).await?; - jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await?; - jvm.put_field(&mut this, "positivePrefix", "Ljava/lang/String;", positive_prefix).await?; - jvm.put_field(&mut this, "positiveSuffix", "Ljava/lang/String;", positive_suffix).await?; - jvm.put_field(&mut this, "negativePrefix", "Ljava/lang/String;", negative_prefix).await?; - jvm.put_field(&mut this, "negativeSuffix", "Ljava/lang/String;", negative_suffix).await?; - jvm.put_field(&mut this, "multiplier", "I", parsed.multiplier).await?; - jvm.put_field(&mut this, "groupingSize", "I", parsed.grouping_size).await?; - jvm.put_field(&mut this, "groupingUsed", "Z", parsed.grouping_used).await?; - jvm.put_field(&mut this, "maximumIntegerDigits", "I", 309).await?; - jvm.put_field(&mut this, "minimumIntegerDigits", "I", parsed.minimum_integer_digits) + jvm.put_field(&mut this, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;", pattern) .await?; - jvm.put_field(&mut this, "maximumFractionDigits", "I", parsed.maximum_fraction_digits) + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "positivePrefix", + "Ljava/lang/String;", + positive_prefix, + ) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "positiveSuffix", + "Ljava/lang/String;", + positive_suffix, + ) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "negativePrefix", + "Ljava/lang/String;", + negative_prefix, + ) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "negativeSuffix", + "Ljava/lang/String;", + negative_suffix, + ) + .await?; + jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", parsed.multiplier) .await?; - jvm.put_field(&mut this, "minimumFractionDigits", "I", parsed.minimum_fraction_digits) - .await + jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingSize", "I", parsed.grouping_size) + .await?; + jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingUsed", "Z", parsed.grouping_used) + .await?; + jvm.put_field(&mut this, "java/text/DecimalFormat", "maximumIntegerDigits", "I", 309) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "minimumIntegerDigits", + "I", + parsed.minimum_integer_digits, + ) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "maximumFractionDigits", + "I", + parsed.maximum_fraction_digits, + ) + .await?; + jvm.put_field( + &mut this, + "java/text/DecimalFormat", + "minimumFractionDigits", + "I", + parsed.minimum_fraction_digits, + ) + .await } async fn append_formatted( @@ -292,11 +343,11 @@ impl DecimalFormat { if buffer.is_null() || position.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await); } - let minimum_integer_digits: i32 = jvm.get_field(this, "minimumIntegerDigits", "I").await?; - let maximum_integer_digits: i32 = jvm.get_field(this, "maximumIntegerDigits", "I").await?; - let minimum_fraction_digits: i32 = jvm.get_field(this, "minimumFractionDigits", "I").await?; - let grouping_used: bool = jvm.get_field(this, "groupingUsed", "Z").await?; - let grouping_size: i32 = jvm.get_field(this, "groupingSize", "I").await?; + let minimum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumIntegerDigits", "I").await?; + let maximum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "maximumIntegerDigits", "I").await?; + let minimum_fraction_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumFractionDigits", "I").await?; + let grouping_used: bool = jvm.get_field(this, "java/text/DecimalFormat", "groupingUsed", "Z").await?; + let grouping_size: i32 = jvm.get_field(this, "java/text/DecimalFormat", "groupingSize", "I").await?; if integer.len() > maximum_integer_digits.max(0) as usize { integer = integer[integer.len() - maximum_integer_digits.max(0) as usize..].to_string(); @@ -325,10 +376,20 @@ impl DecimalFormat { } let prefix: ClassInstanceRef = jvm - .get_field(this, if negative { "negativePrefix" } else { "positivePrefix" }, "Ljava/lang/String;") + .get_field( + this, + "java/text/DecimalFormat", + if negative { "negativePrefix" } else { "positivePrefix" }, + "Ljava/lang/String;", + ) .await?; let suffix: ClassInstanceRef = jvm - .get_field(this, if negative { "negativeSuffix" } else { "positiveSuffix" }, "Ljava/lang/String;") + .get_field( + this, + "java/text/DecimalFormat", + if negative { "negativeSuffix" } else { "positiveSuffix" }, + "Ljava/lang/String;", + ) .await?; let prefix = JavaLangString::to_rust_string(jvm, &prefix).await?; let suffix = JavaLangString::to_rust_string(jvm, &suffix).await?; @@ -407,12 +468,12 @@ impl DecimalFormat { } let negative = value.is_sign_negative(); - let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?; + let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?; let scaled = value.abs() * f64::from(multiplier); if scaled.is_infinite() { return Self::append_formatted(jvm, &this, negative, "\u{221e}".to_string(), RustString::new(), buffer, position).await; } - let maximum_fraction_digits: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?; + let maximum_fraction_digits: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "maximumFractionDigits", "I").await?; let precision = maximum_fraction_digits.clamp(0, 340) as usize; let numeric = format!("{scaled:.precision$}"); let (integer, fraction) = numeric @@ -430,7 +491,7 @@ impl DecimalFormat { buffer: ClassInstanceRef, position: ClassInstanceRef, ) -> Result> { - let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?; + let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?; let scaled = i128::from(value) * i128::from(multiplier); let negative = scaled < 0; Self::append_formatted( @@ -478,10 +539,18 @@ impl DecimalFormat { return Ok(ClassInstanceRef::new(None)); }; - let positive_prefix: ClassInstanceRef = jvm.get_field(&this, "positivePrefix", "Ljava/lang/String;").await?; - let positive_suffix: ClassInstanceRef = jvm.get_field(&this, "positiveSuffix", "Ljava/lang/String;").await?; - let negative_prefix: ClassInstanceRef = jvm.get_field(&this, "negativePrefix", "Ljava/lang/String;").await?; - let negative_suffix: ClassInstanceRef = jvm.get_field(&this, "negativeSuffix", "Ljava/lang/String;").await?; + let positive_prefix: ClassInstanceRef = jvm + .get_field(&this, "java/text/DecimalFormat", "positivePrefix", "Ljava/lang/String;") + .await?; + let positive_suffix: ClassInstanceRef = jvm + .get_field(&this, "java/text/DecimalFormat", "positiveSuffix", "Ljava/lang/String;") + .await?; + let negative_prefix: ClassInstanceRef = jvm + .get_field(&this, "java/text/DecimalFormat", "negativePrefix", "Ljava/lang/String;") + .await?; + let negative_suffix: ClassInstanceRef = jvm + .get_field(&this, "java/text/DecimalFormat", "negativeSuffix", "Ljava/lang/String;") + .await?; let positive_prefix: Vec = JavaLangString::to_rust_string(jvm, &positive_prefix).await?.chars().collect(); let positive_suffix: Vec = JavaLangString::to_rust_string(jvm, &positive_suffix).await?.chars().collect(); let negative_prefix: Vec = JavaLangString::to_rust_string(jvm, &negative_prefix).await?.chars().collect(); @@ -501,7 +570,7 @@ impl DecimalFormat { return Ok(ClassInstanceRef::new(None)); }; - let parse_integer_only: bool = jvm.get_field(&this, "parseIntegerOnly", "Z").await?; + let parse_integer_only: bool = jvm.get_field(&this, "java/text/DecimalFormat", "parseIntegerOnly", "Z").await?; let mut normalized = RustString::new(); let mut digits = 0; let mut decimal = false; @@ -581,7 +650,7 @@ impl DecimalFormat { .await?; return Ok(ClassInstanceRef::new(None)); }; - let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?; + let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?; if multiplier != 0 { value /= f64::from(multiplier); } @@ -608,14 +677,14 @@ impl DecimalFormat { } async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "pattern", "Ljava/lang/String;").await + jvm.get_field(&this, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;").await } async fn get_multiplier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "multiplier", "I").await + jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await } async fn set_multiplier(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, multiplier: i32) -> Result<()> { - jvm.put_field(&mut this, "multiplier", "I", multiplier).await + jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", multiplier).await } } diff --git a/rustjava-runtime/src/classes/java/text/field_position.rs b/rustjava-runtime/src/classes/java/text/field_position.rs index 52b01564..41adc9f0 100644 --- a/rustjava-runtime/src/classes/java/text/field_position.rs +++ b/rustjava-runtime/src/classes/java/text/field_position.rs @@ -40,29 +40,29 @@ impl FieldPosition { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, field: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "field", "I", field).await?; - jvm.put_field(&mut this, "beginIndex", "I", 0).await?; - jvm.put_field(&mut this, "endIndex", "I", 0).await + jvm.put_field(&mut this, "java/text/FieldPosition", "field", "I", field).await?; + jvm.put_field(&mut this, "java/text/FieldPosition", "beginIndex", "I", 0).await?; + jvm.put_field(&mut this, "java/text/FieldPosition", "endIndex", "I", 0).await } async fn get_field(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "field", "I").await + jvm.get_field(&this, "java/text/FieldPosition", "field", "I").await } async fn get_begin_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "beginIndex", "I").await + jvm.get_field(&this, "java/text/FieldPosition", "beginIndex", "I").await } async fn get_end_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "endIndex", "I").await + jvm.get_field(&this, "java/text/FieldPosition", "endIndex", "I").await } async fn set_begin_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { - jvm.put_field(&mut this, "beginIndex", "I", value).await + jvm.put_field(&mut this, "java/text/FieldPosition", "beginIndex", "I", value).await } async fn set_end_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { - jvm.put_field(&mut this, "endIndex", "I", value).await + jvm.put_field(&mut this, "java/text/FieldPosition", "endIndex", "I", value).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -71,26 +71,26 @@ impl FieldPosition { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let field: i32 = jvm.get_field(&this, "field", "I").await?; - let other_field: i32 = jvm.get_field(&other, "field", "I").await?; - let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?; - let other_begin_index: i32 = jvm.get_field(&other, "beginIndex", "I").await?; - let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?; - let other_end_index: i32 = jvm.get_field(&other, "endIndex", "I").await?; + let field: i32 = jvm.get_field(&this, "java/text/FieldPosition", "field", "I").await?; + let other_field: i32 = jvm.get_field(&other, "java/text/FieldPosition", "field", "I").await?; + let begin_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "beginIndex", "I").await?; + let other_begin_index: i32 = jvm.get_field(&other, "java/text/FieldPosition", "beginIndex", "I").await?; + let end_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "endIndex", "I").await?; + let other_end_index: i32 = jvm.get_field(&other, "java/text/FieldPosition", "endIndex", "I").await?; Ok(field == other_field && begin_index == other_begin_index && end_index == other_end_index) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let field: i32 = jvm.get_field(&this, "field", "I").await?; - let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?; - let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?; + let field: i32 = jvm.get_field(&this, "java/text/FieldPosition", "field", "I").await?; + let begin_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "beginIndex", "I").await?; + let end_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "endIndex", "I").await?; Ok(field ^ begin_index.rotate_left(11) ^ end_index.rotate_left(22)) } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let field: i32 = jvm.get_field(&this, "field", "I").await?; - let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?; - let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?; + let field: i32 = jvm.get_field(&this, "java/text/FieldPosition", "field", "I").await?; + let begin_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "beginIndex", "I").await?; + let end_index: i32 = jvm.get_field(&this, "java/text/FieldPosition", "endIndex", "I").await?; Ok(JavaLangString::from_rust_string( jvm, &format!("java.text.FieldPosition[field={field},beginIndex={begin_index},endIndex={end_index}]"), diff --git a/rustjava-runtime/src/classes/java/text/number_format.rs b/rustjava-runtime/src/classes/java/text/number_format.rs index ab467160..c64a81f1 100644 --- a/rustjava-runtime/src/classes/java/text/number_format.rs +++ b/rustjava-runtime/src/classes/java/text/number_format.rs @@ -215,12 +215,14 @@ impl NumberFormat { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/text/Format", "", "()V", ()).await?; - jvm.put_field(&mut this, "groupingUsed", "Z", true).await?; - jvm.put_field(&mut this, "parseIntegerOnly", "Z", false).await?; - jvm.put_field(&mut this, "maximumIntegerDigits", "I", 40).await?; - jvm.put_field(&mut this, "minimumIntegerDigits", "I", 1).await?; - jvm.put_field(&mut this, "maximumFractionDigits", "I", 3).await?; - jvm.put_field(&mut this, "minimumFractionDigits", "I", 0).await + jvm.put_field(&mut this, "java/text/NumberFormat", "groupingUsed", "Z", true).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "parseIntegerOnly", "Z", false).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", 40) + .await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", 1).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", 3) + .await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", 0).await } async fn format_object( @@ -470,73 +472,81 @@ impl NumberFormat { } async fn is_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "groupingUsed", "Z").await + jvm.get_field(&this, "java/text/NumberFormat", "groupingUsed", "Z").await } async fn set_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: bool) -> Result<()> { - jvm.put_field(&mut this, "groupingUsed", "Z", value).await + jvm.put_field(&mut this, "java/text/NumberFormat", "groupingUsed", "Z", value).await } async fn is_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "parseIntegerOnly", "Z").await + jvm.get_field(&this, "java/text/NumberFormat", "parseIntegerOnly", "Z").await } async fn set_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: bool) -> Result<()> { - jvm.put_field(&mut this, "parseIntegerOnly", "Z", value).await + jvm.put_field(&mut this, "java/text/NumberFormat", "parseIntegerOnly", "Z", value).await } async fn get_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "maximumIntegerDigits", "I").await + jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await } async fn set_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { let value = value.max(0); - jvm.put_field(&mut this, "maximumIntegerDigits", "I", value).await?; - let minimum: i32 = jvm.get_field(&this, "minimumIntegerDigits", "I").await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", value) + .await?; + let minimum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "minimumIntegerDigits", "I").await?; if minimum > value { - jvm.put_field(&mut this, "minimumIntegerDigits", "I", value).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", value) + .await?; } Ok(()) } async fn get_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "minimumIntegerDigits", "I").await + jvm.get_field(&this, "java/text/NumberFormat", "minimumIntegerDigits", "I").await } async fn set_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { let value = value.max(0); - jvm.put_field(&mut this, "minimumIntegerDigits", "I", value).await?; - let maximum: i32 = jvm.get_field(&this, "maximumIntegerDigits", "I").await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", value) + .await?; + let maximum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await?; if maximum < value { - jvm.put_field(&mut this, "maximumIntegerDigits", "I", value).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", value) + .await?; } Ok(()) } async fn get_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "maximumFractionDigits", "I").await + jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await } async fn set_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { let value = value.max(0); - jvm.put_field(&mut this, "maximumFractionDigits", "I", value).await?; - let minimum: i32 = jvm.get_field(&this, "minimumFractionDigits", "I").await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", value) + .await?; + let minimum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "minimumFractionDigits", "I").await?; if minimum > value { - jvm.put_field(&mut this, "minimumFractionDigits", "I", value).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", value) + .await?; } Ok(()) } async fn get_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "minimumFractionDigits", "I").await + jvm.get_field(&this, "java/text/NumberFormat", "minimumFractionDigits", "I").await } async fn set_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { let value = value.max(0); - jvm.put_field(&mut this, "minimumFractionDigits", "I", value).await?; - let maximum: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", value) + .await?; + let maximum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await?; if maximum < value { - jvm.put_field(&mut this, "maximumFractionDigits", "I", value).await?; + jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", value) + .await?; } Ok(()) } @@ -555,14 +565,14 @@ impl NumberFormat { ("minimumFractionDigits", "I"), ] { if descriptor == "Z" { - let value: bool = jvm.get_field(&this, name, descriptor).await?; - let other_value: bool = jvm.get_field(&other, name, descriptor).await?; + let value: bool = jvm.get_field(&this, "java/text/NumberFormat", name, descriptor).await?; + let other_value: bool = jvm.get_field(&other, "java/text/NumberFormat", name, descriptor).await?; if value != other_value { return Ok(false); } } else { - let value: i32 = jvm.get_field(&this, name, descriptor).await?; - let other_value: i32 = jvm.get_field(&other, name, descriptor).await?; + let value: i32 = jvm.get_field(&this, "java/text/NumberFormat", name, descriptor).await?; + let other_value: i32 = jvm.get_field(&other, "java/text/NumberFormat", name, descriptor).await?; if value != other_value { return Ok(false); } @@ -572,8 +582,8 @@ impl NumberFormat { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let maximum_integer_digits: i32 = jvm.get_field(&this, "maximumIntegerDigits", "I").await?; - let maximum_fraction_digits: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?; + let maximum_integer_digits: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await?; + let maximum_fraction_digits: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await?; Ok(maximum_integer_digits * 37 + maximum_fraction_digits) } } diff --git a/rustjava-runtime/src/classes/java/text/parse_exception.rs b/rustjava-runtime/src/classes/java/text/parse_exception.rs index 14d2c2b1..289a3c6e 100644 --- a/rustjava-runtime/src/classes/java/text/parse_exception.rs +++ b/rustjava-runtime/src/classes/java/text/parse_exception.rs @@ -34,10 +34,11 @@ impl ParseException { let _: () = jvm .invoke_special(&this, "java/lang/Exception", "", "(Ljava/lang/String;)V", (message,)) .await?; - jvm.put_field(&mut this, "errorOffset", "I", error_offset).await + jvm.put_field(&mut this, "java/text/ParseException", "errorOffset", "I", error_offset) + .await } async fn get_error_offset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "errorOffset", "I").await + jvm.get_field(&this, "java/text/ParseException", "errorOffset", "I").await } } diff --git a/rustjava-runtime/src/classes/java/text/parse_position.rs b/rustjava-runtime/src/classes/java/text/parse_position.rs index c03d9560..3d60017e 100644 --- a/rustjava-runtime/src/classes/java/text/parse_position.rs +++ b/rustjava-runtime/src/classes/java/text/parse_position.rs @@ -38,24 +38,24 @@ impl ParsePosition { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "index", "I", index).await?; - jvm.put_field(&mut this, "errorIndex", "I", -1).await + jvm.put_field(&mut this, "java/text/ParsePosition", "index", "I", index).await?; + jvm.put_field(&mut this, "java/text/ParsePosition", "errorIndex", "I", -1).await } async fn get_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "index", "I").await + jvm.get_field(&this, "java/text/ParsePosition", "index", "I").await } async fn set_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result<()> { - jvm.put_field(&mut this, "index", "I", index).await + jvm.put_field(&mut this, "java/text/ParsePosition", "index", "I", index).await } async fn get_error_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "errorIndex", "I").await + jvm.get_field(&this, "java/text/ParsePosition", "errorIndex", "I").await } async fn set_error_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result<()> { - jvm.put_field(&mut this, "errorIndex", "I", index).await + jvm.put_field(&mut this, "java/text/ParsePosition", "errorIndex", "I", index).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -64,22 +64,22 @@ impl ParsePosition { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let index: i32 = jvm.get_field(&this, "index", "I").await?; - let other_index: i32 = jvm.get_field(&other, "index", "I").await?; - let error_index: i32 = jvm.get_field(&this, "errorIndex", "I").await?; - let other_error_index: i32 = jvm.get_field(&other, "errorIndex", "I").await?; + let index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "index", "I").await?; + let other_index: i32 = jvm.get_field(&other, "java/text/ParsePosition", "index", "I").await?; + let error_index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "errorIndex", "I").await?; + let other_error_index: i32 = jvm.get_field(&other, "java/text/ParsePosition", "errorIndex", "I").await?; Ok(index == other_index && error_index == other_error_index) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let index: i32 = jvm.get_field(&this, "index", "I").await?; - let error_index: i32 = jvm.get_field(&this, "errorIndex", "I").await?; + let index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "index", "I").await?; + let error_index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "errorIndex", "I").await?; Ok(index ^ error_index.rotate_left(16)) } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let index: i32 = jvm.get_field(&this, "index", "I").await?; - let error_index: i32 = jvm.get_field(&this, "errorIndex", "I").await?; + let index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "index", "I").await?; + let error_index: i32 = jvm.get_field(&this, "java/text/ParsePosition", "errorIndex", "I").await?; Ok( JavaLangString::from_rust_string(jvm, &format!("java.text.ParsePosition[index={index},errorIndex={error_index}]")) .await? diff --git a/rustjava-runtime/src/classes/java/text/simple_date_format.rs b/rustjava-runtime/src/classes/java/text/simple_date_format.rs index 634d2c42..0a9d2649 100644 --- a/rustjava-runtime/src/classes/java/text/simple_date_format.rs +++ b/rustjava-runtime/src/classes/java/text/simple_date_format.rs @@ -393,7 +393,8 @@ impl SimpleDateFormat { return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await); } let _: () = jvm.invoke_special(&this, "java/text/DateFormat", "", "()V", ()).await?; - jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await + jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern) + .await } async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, pattern: ClassInstanceRef) -> Result<()> { @@ -404,11 +405,12 @@ impl SimpleDateFormat { if Self::tokenize_pattern(&value).is_none() { return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await); } - jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await + jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern) + .await } async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "pattern", "Ljava/lang/String;").await + jvm.get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;").await } async fn format( @@ -422,13 +424,17 @@ impl SimpleDateFormat { if date.is_null() || buffer.is_null() || position.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "date, buffer, or position").await); } - let pattern: ClassInstanceRef = jvm.get_field(&this, "pattern", "Ljava/lang/String;").await?; + let pattern: ClassInstanceRef = jvm + .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;") + .await?; let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?; let Some(tokens) = Self::tokenize_pattern(&pattern) else { return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await); }; let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?; - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm + .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;") + .await?; let time_zone: ClassInstanceRef = jvm .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ()) .await?; @@ -550,7 +556,9 @@ impl SimpleDateFormat { if source.is_null() || position.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "source or position").await); } - let pattern: ClassInstanceRef = jvm.get_field(&this, "pattern", "Ljava/lang/String;").await?; + let pattern: ClassInstanceRef = jvm + .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;") + .await?; let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?; let Some(tokens) = Self::tokenize_pattern(&pattern) else { return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await); @@ -577,7 +585,9 @@ impl SimpleDateFormat { .await?; return Ok(ClassInstanceRef::new(None)); }; - let calendar: ClassInstanceRef = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?; + let calendar: ClassInstanceRef = jvm + .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;") + .await?; let time_zone: ClassInstanceRef = jvm .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ()) .await?; diff --git a/rustjava-runtime/src/classes/java/util/abstract_list.rs b/rustjava-runtime/src/classes/java/util/abstract_list.rs index 3e2ee256..2eb6d9ca 100644 --- a/rustjava-runtime/src/classes/java/util/abstract_list.rs +++ b/rustjava-runtime/src/classes/java/util/abstract_list.rs @@ -297,14 +297,15 @@ impl AbstractListItr { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "list iterator index").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "list", "Ljava/util/List;", list).await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;", list) + .await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?; Ok(cursor < jvm .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ()) @@ -312,8 +313,8 @@ impl AbstractListItr { } async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?; if cursor >= jvm .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ()) @@ -324,44 +325,45 @@ impl AbstractListItr { let element = jvm .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (cursor,)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", cursor).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", cursor) + .await?; Ok(element) } async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? > 0) + Ok(jvm.get_field::(&this, "java/util/AbstractList$Itr", "cursor", "I").await? > 0) } async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?; if cursor <= 0 { return Err(jvm.exception("java/util/NoSuchElementException", "AbstractList iterator exhausted").await); } let index = cursor - 1; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; let element = jvm .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (index,)) .await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", index).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", index).await?; Ok(element) } async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "cursor", "I").await + jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await } async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? - 1) + Ok(jvm.get_field::(&this, "java/util/AbstractList$Itr", "cursor", "I").await? - 1) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -371,19 +373,19 @@ impl AbstractListItr { (last_returned,), ) .await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?; if last_returned < cursor { - jvm.put_field(&mut this, "cursor", "I", cursor - 1).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor - 1).await?; } - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await } async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -397,12 +399,12 @@ impl AbstractListItr { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?; let _: () = jvm .invoke_virtual(&list, &list.class_definition().name(), "add", "(ILjava/lang/Object;)V", (cursor, element)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await } } diff --git a/rustjava-runtime/src/classes/java/util/abstract_list_sub_list.rs b/rustjava-runtime/src/classes/java/util/abstract_list_sub_list.rs index 55db9ac4..1557e8b8 100644 --- a/rustjava-runtime/src/classes/java/util/abstract_list_sub_list.rs +++ b/rustjava-runtime/src/classes/java/util/abstract_list_sub_list.rs @@ -73,23 +73,31 @@ impl AbstractListSubList { size: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; - jvm.put_field(&mut this, "root", "Ljava/util/List;", root).await?; - jvm.put_field(&mut this, "parent", "Ljava/util/AbstractList$SubList;", parent).await?; - jvm.put_field(&mut this, "offset", "I", offset).await?; - jvm.put_field(&mut this, "size", "I", size).await + jvm.put_field(&mut this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;", root) + .await?; + jvm.put_field( + &mut this, + "java/util/AbstractList$SubList", + "parent", + "Ljava/util/AbstractList$SubList;", + parent, + ) + .await?; + jvm.put_field(&mut this, "java/util/AbstractList$SubList", "offset", "I", offset).await?; + jvm.put_field(&mut this, "java/util/AbstractList$SubList", "size", "I", size).await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if index < 0 || index >= size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; jvm.invoke_virtual(&root, &root.class_definition().name(), "get", "(I)Ljava/lang/Object;", (offset + index,)) .await } @@ -101,12 +109,12 @@ impl AbstractListSubList { index: i32, element: ClassInstanceRef, ) -> Result> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if index < 0 || index >= size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; jvm.invoke_virtual( &root, &root.class_definition().name(), @@ -118,7 +126,7 @@ impl AbstractListSubList { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; let _: () = jvm .invoke_virtual(&this, "java/util/AbstractList$SubList", "add", "(ILjava/lang/Object;)V", (size, element)) .await?; @@ -126,12 +134,12 @@ impl AbstractListSubList { } async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32, element: ClassInstanceRef) -> Result<()> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if index < 0 || index > size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; let _: () = jvm .invoke_virtual( &root, @@ -145,7 +153,7 @@ impl AbstractListSubList { } async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, collection: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; jvm.invoke_virtual( &this, "java/util/AbstractList$SubList", @@ -163,7 +171,7 @@ impl AbstractListSubList { index: i32, collection: ClassInstanceRef, ) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if index < 0 || index > size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await); } @@ -177,8 +185,8 @@ impl AbstractListSubList { { return Ok(false); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; let old_root_size: i32 = jvm.invoke_virtual(&root, &root.class_definition().name(), "size", "()I", ()).await?; let modified: bool = jvm .invoke_virtual( @@ -197,12 +205,12 @@ impl AbstractListSubList { } async fn remove_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if index < 0 || index >= size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; let removed = jvm .invoke_virtual( &root, @@ -230,7 +238,7 @@ impl AbstractListSubList { } async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; for index in 0..size { let current: ClassInstanceRef = jvm .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,)) @@ -248,7 +256,7 @@ impl AbstractListSubList { } async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; for index in (0..size).rev() { let current: ClassInstanceRef = jvm .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,)) @@ -266,7 +274,7 @@ impl AbstractListSubList { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - while jvm.get_field::(&this, "size", "I").await? > 0 { + while jvm.get_field::(&this, "java/util/AbstractList$SubList", "size", "I").await? > 0 { let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/util/AbstractList$SubList", "remove", "(I)Ljava/lang/Object;", (0,)) .await?; @@ -292,15 +300,15 @@ impl AbstractListSubList { } async fn sub_list(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, from: i32, to: i32) -> Result> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?; if from < 0 || to > size { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList range").await); } if from > to { return Err(jvm.exception("java/lang/IllegalArgumentException", "fromIndex > toIndex").await); } - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/List;").await?; - let offset: i32 = jvm.get_field(&this, "offset", "I").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?; + let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?; let sub_list = jvm .new_class( "java/util/AbstractList$SubList", @@ -313,9 +321,12 @@ impl AbstractListSubList { async fn update_sizes(jvm: &Jvm, mut current: ClassInstanceRef, delta: i32) -> Result<()> { while !current.is_null() { - let size: i32 = jvm.get_field(¤t, "size", "I").await?; - jvm.put_field(&mut current, "size", "I", size + delta).await?; - current = jvm.get_field(¤t, "parent", "Ljava/util/AbstractList$SubList;").await?; + let size: i32 = jvm.get_field(¤t, "java/util/AbstractList$SubList", "size", "I").await?; + jvm.put_field(&mut current, "java/util/AbstractList$SubList", "size", "I", size + delta) + .await?; + current = jvm + .get_field(¤t, "java/util/AbstractList$SubList", "parent", "Ljava/util/AbstractList$SubList;") + .await?; } Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/array_list.rs b/rustjava-runtime/src/classes/java/util/array_list.rs index 2a465805..801db101 100644 --- a/rustjava-runtime/src/classes/java/util/array_list.rs +++ b/rustjava-runtime/src/classes/java/util/array_list.rs @@ -78,8 +78,9 @@ impl ArrayList { let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; let element_data = jvm.instantiate_array("Ljava/lang/Object;", capacity as usize).await?; - jvm.put_field(&mut this, "elementData", "[Ljava/lang/Object;", element_data).await?; - jvm.put_field(&mut this, "size", "I", 0).await?; + jvm.put_field(&mut this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;", element_data) + .await?; + jvm.put_field(&mut this, "java/util/ArrayList", "size", "I", 0).await?; Ok(()) } @@ -109,12 +110,12 @@ impl ArrayList { async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.ArrayList::add({this:?}, {element:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; Self::ensure_capacity(jvm, &mut this, (size + 1) as usize).await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; jvm.store_array(&mut element_data, size as usize, core::iter::once(element)).await?; - jvm.put_field(&mut this, "size", "I", size + 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList", "size", "I", size + 1).await?; Ok(true) } @@ -128,14 +129,14 @@ impl ArrayList { ) -> Result<()> { tracing::debug!("java.util.ArrayList::add({this:?}, {index:?}, {element:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; if index < 0 || index > size { return Err(Self::index_out_of_bounds(jvm, index, size).await); } Self::ensure_capacity(jvm, &mut this, (size + 1) as usize).await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let num_to_move = size - index; if num_to_move > 0 { let to_shift: Vec> = jvm.load_array(&element_data, index as usize, num_to_move as usize).await?; @@ -143,7 +144,7 @@ impl ArrayList { } jvm.store_array(&mut element_data, index as usize, core::iter::once(element)).await?; - jvm.put_field(&mut this, "size", "I", size + 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList", "size", "I", size + 1).await?; Ok(()) } @@ -151,12 +152,12 @@ impl ArrayList { async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { tracing::debug!("java.util.ArrayList::get({this:?}, {index:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; if index < 0 || index >= size { return Err(Self::index_out_of_bounds(jvm, index, size).await); } - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let element: ClassInstanceRef = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap(); Ok(element) @@ -171,12 +172,12 @@ impl ArrayList { ) -> Result> { tracing::debug!("java.util.ArrayList::set({this:?}, {index:?}, {element:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; if index < 0 || index >= size { return Err(Self::index_out_of_bounds(jvm, index, size).await); } - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let old_element: ClassInstanceRef = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap(); jvm.store_array(&mut element_data, index as usize, core::iter::once(element)).await?; @@ -186,12 +187,12 @@ impl ArrayList { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result> { tracing::debug!("java.util.ArrayList::remove({this:?}, {index:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; if index < 0 || index >= size { return Err(Self::index_out_of_bounds(jvm, index, size).await); } - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let removed: ClassInstanceRef = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap(); let num_to_move = size - index - 1; @@ -203,7 +204,7 @@ impl ArrayList { let null_ref: ClassInstanceRef = None.into(); jvm.store_array(&mut element_data, (size - 1) as usize, core::iter::once(null_ref)) .await?; - jvm.put_field(&mut this, "size", "I", size - 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList", "size", "I", size - 1).await?; Ok(removed) } @@ -228,13 +229,13 @@ impl ArrayList { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.ArrayList::size({this:?})"); - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "java/util/ArrayList", "size", "I").await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.ArrayList::isEmpty({this:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; Ok(size == 0) } @@ -252,8 +253,8 @@ impl ArrayList { async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.ArrayList::indexOf({this:?}, {element:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; + let element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; for index in 0..size { let item: ClassInstanceRef = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap(); @@ -268,14 +269,14 @@ impl ArrayList { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.ArrayList::clear({this:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; if size > 0 { - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let nulls: Vec> = (0..size).map(|_| None.into()).collect(); jvm.store_array(&mut element_data, 0, nulls).await?; } - jvm.put_field(&mut this, "size", "I", 0).await?; + jvm.put_field(&mut this, "java/util/ArrayList", "size", "I", 0).await?; Ok(()) } @@ -283,8 +284,8 @@ impl ArrayList { async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { tracing::debug!("java.util.ArrayList::toArray({this:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; - let element_data: ClassInstanceRef> = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let size: i32 = jvm.get_field(&this, "java/util/ArrayList", "size", "I").await?; + let element_data: ClassInstanceRef> = jvm.get_field(&this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; Self::copy_to_array(jvm, &element_data, size).await } @@ -310,7 +311,7 @@ impl ArrayList { } async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef, min_capacity: usize) -> Result<()> { - let element_data = jvm.get_field(this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;").await?; let current_capacity = jvm.array_length(&element_data).await?; if min_capacity <= current_capacity { @@ -318,14 +319,15 @@ impl ArrayList { } let new_capacity = if current_capacity == 0 { 1 } else { current_capacity * 2 }.max(min_capacity); - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/ArrayList", "size", "I").await?; let old_elements: Vec> = jvm.load_array(&element_data, 0, size as usize).await?; let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", new_capacity).await?; if !old_elements.is_empty() { jvm.store_array(&mut new_element_data, 0, old_elements).await?; } - jvm.put_field(this, "elementData", "[Ljava/lang/Object;", new_element_data).await?; + jvm.put_field(this, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;", new_element_data) + .await?; Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/array_list_itr.rs b/rustjava-runtime/src/classes/java/util/array_list_itr.rs index 1478438d..be48ebd6 100644 --- a/rustjava-runtime/src/classes/java/util/array_list_itr.rs +++ b/rustjava-runtime/src/classes/java/util/array_list_itr.rs @@ -57,21 +57,22 @@ impl ArrayListItr { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "list iterator index").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "list", "Ljava/util/List;", list).await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;", list) + .await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "lastReturned", "I", -1).await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await?; let size: i32 = jvm.invoke_virtual(&list, &list.class_definition().name(), "size", "()I", ()).await?; Ok(cursor < size) } async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await?; let size: i32 = jvm.invoke_virtual(&list, &list.class_definition().name(), "size", "()I", ()).await?; if cursor >= size { return Err(jvm.exception("java/util/NoSuchElementException", "ArrayList iterator exhausted").await); @@ -79,44 +80,44 @@ impl ArrayListItr { let element = jvm .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (cursor,)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", cursor).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "lastReturned", "I", cursor).await?; Ok(element) } async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? > 0) + Ok(jvm.get_field::(&this, "java/util/ArrayList$Itr", "cursor", "I").await? > 0) } async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await?; if cursor <= 0 { return Err(jvm.exception("java/util/NoSuchElementException", "ArrayList iterator exhausted").await); } let index = cursor - 1; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; let element = jvm .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (index,)) .await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", index).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "lastReturned", "I", index).await?; Ok(element) } async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "cursor", "I").await + jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await } async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? - 1) + Ok(jvm.get_field::(&this, "java/util/ArrayList$Itr", "cursor", "I").await? - 1) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -126,19 +127,19 @@ impl ArrayListItr { (last_returned,), ) .await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await?; if last_returned < cursor { - jvm.put_field(&mut this, "cursor", "I", cursor - 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "cursor", "I", cursor - 1).await?; } - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "lastReturned", "I", -1).await } async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -152,12 +153,12 @@ impl ArrayListItr { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/ArrayList$Itr", "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/ArrayList$Itr", "list", "Ljava/util/List;").await?; let _: () = jvm .invoke_virtual(&list, &list.class_definition().name(), "add", "(ILjava/lang/Object;)V", (cursor, element)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/ArrayList$Itr", "lastReturned", "I", -1).await } } diff --git a/rustjava-runtime/src/classes/java/util/arrays_array_list.rs b/rustjava-runtime/src/classes/java/util/arrays_array_list.rs index 191a8dd7..f4e10556 100644 --- a/rustjava-runtime/src/classes/java/util/arrays_array_list.rs +++ b/rustjava-runtime/src/classes/java/util/arrays_array_list.rs @@ -37,16 +37,17 @@ impl ArraysArrayList { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, array: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; - jvm.put_field(&mut this, "a", "[Ljava/lang/Object;", array).await + jvm.put_field(&mut this, "java/util/Arrays$ArrayList", "a", "[Ljava/lang/Object;", array) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let array: ClassInstanceRef> = jvm.get_field(&this, "a", "[Ljava/lang/Object;").await?; + let array: ClassInstanceRef> = jvm.get_field(&this, "java/util/Arrays$ArrayList", "a", "[Ljava/lang/Object;").await?; Ok(jvm.array_length(&array).await? as i32) } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let array: ClassInstanceRef> = jvm.get_field(&this, "a", "[Ljava/lang/Object;").await?; + let array: ClassInstanceRef> = jvm.get_field(&this, "java/util/Arrays$ArrayList", "a", "[Ljava/lang/Object;").await?; let length = jvm.array_length(&array).await?; if index < 0 || index as usize >= length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await); @@ -61,7 +62,7 @@ impl ArraysArrayList { index: i32, element: ClassInstanceRef, ) -> Result> { - let mut array: ClassInstanceRef> = jvm.get_field(&this, "a", "[Ljava/lang/Object;").await?; + let mut array: ClassInstanceRef> = jvm.get_field(&this, "java/util/Arrays$ArrayList", "a", "[Ljava/lang/Object;").await?; let length = jvm.array_length(&array).await?; if index < 0 || index as usize >= length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await); diff --git a/rustjava-runtime/src/classes/java/util/calendar.rs b/rustjava-runtime/src/classes/java/util/calendar.rs index 264c1833..6857fb22 100644 --- a/rustjava-runtime/src/classes/java/util/calendar.rs +++ b/rustjava-runtime/src/classes/java/util/calendar.rs @@ -105,12 +105,13 @@ impl Calendar { // TODO constant let fields = jvm.instantiate_array("I", 17).await?; - jvm.put_field(&mut this, "fields", "[I", fields).await?; + jvm.put_field(&mut this, "java/util/Calendar", "fields", "[I", fields).await?; let time_zone: ClassInstanceRef = jvm .invoke_static("java/util/TimeZone", "getDefault", "()Ljava/util/TimeZone;", ()) .await?; - jvm.put_field(&mut this, "timeZone", "Ljava/util/TimeZone;", time_zone).await?; - jvm.put_field(&mut this, "lenient", "Z", true).await?; + jvm.put_field(&mut this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;", time_zone) + .await?; + jvm.put_field(&mut this, "java/util/Calendar", "lenient", "Z", true).await?; Ok(()) } @@ -123,7 +124,7 @@ impl Calendar { } let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?; - jvm.put_field(&mut this, "time", "J", time).await?; + jvm.put_field(&mut this, "java/util/Calendar", "time", "J", time).await?; let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await?; @@ -133,7 +134,7 @@ impl Calendar { async fn get_time(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Calendar::getTime({this:?})"); - let time: i64 = jvm.get_field(&this, "time", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?; let date = jvm.new_class("java/util/Date", "(J)V", (time,)).await?; Ok(date.into()) @@ -142,18 +143,18 @@ impl Calendar { async fn set_time_in_millis(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, time: i64) -> Result<()> { tracing::debug!("java.util.Calendar::setTimeInMillis({this:?}, {time:?})"); - jvm.put_field(&mut this, "time", "J", time).await?; + jvm.put_field(&mut this, "java/util/Calendar", "time", "J", time).await?; jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await } async fn get_time_in_millis(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Calendar::getTimeInMillis({this:?})"); - jvm.get_field(&this, "time", "J").await + jvm.get_field(&this, "java/util/Calendar", "time", "J").await } async fn get_time_zone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Calendar::getTimeZone({this:?})"); - jvm.get_field(&this, "timeZone", "Ljava/util/TimeZone;").await + jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await } async fn set_time_zone(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, time_zone: ClassInstanceRef) -> Result<()> { @@ -161,18 +162,19 @@ impl Calendar { if time_zone.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await); } - jvm.put_field(&mut this, "timeZone", "Ljava/util/TimeZone;", time_zone).await?; + jvm.put_field(&mut this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;", time_zone) + .await?; jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await } async fn is_lenient(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Calendar::isLenient({this:?})"); - jvm.get_field(&this, "lenient", "Z").await + jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await } async fn set_lenient(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, lenient: bool) -> Result<()> { tracing::debug!("java.util.Calendar::setLenient({this:?}, {lenient:?})"); - jvm.put_field(&mut this, "lenient", "Z", lenient).await + jvm.put_field(&mut this, "java/util/Calendar", "lenient", "Z", lenient).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -183,20 +185,20 @@ impl Calendar { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let time: i64 = jvm.get_field(&this, "time", "J").await?; - let other_time: i64 = jvm.get_field(&other, "time", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?; + let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?; if time != other_time { return Ok(false); } - let lenient: bool = jvm.get_field(&this, "lenient", "Z").await?; - let other_lenient: bool = jvm.get_field(&other, "lenient", "Z").await?; + let lenient: bool = jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await?; + let other_lenient: bool = jvm.get_field(&other, "java/util/Calendar", "lenient", "Z").await?; if lenient != other_lenient { return Ok(false); } - let time_zone: ClassInstanceRef = jvm.get_field(&this, "timeZone", "Ljava/util/TimeZone;").await?; - let other_time_zone: ClassInstanceRef = jvm.get_field(&other, "timeZone", "Ljava/util/TimeZone;").await?; + let time_zone: ClassInstanceRef = jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?; + let other_time_zone: ClassInstanceRef = jvm.get_field(&other, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?; let raw_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?; let other_raw_offset: i32 = jvm .invoke_virtual(&other_time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()) @@ -218,14 +220,14 @@ impl Calendar { async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Calendar::hashCode({this:?})"); - let time: i64 = jvm.get_field(&this, "time", "J").await?; - let time_zone: ClassInstanceRef = jvm.get_field(&this, "timeZone", "Ljava/util/TimeZone;").await?; + let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?; + let time_zone: ClassInstanceRef = jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?; let raw_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?; let id: ClassInstanceRef = jvm .invoke_virtual(&time_zone, "java/util/TimeZone", "getID", "()Ljava/lang/String;", ()) .await?; let id_hash: i32 = jvm.invoke_virtual(&id, "java/lang/Object", "hashCode", "()I", ()).await?; - let lenient: bool = jvm.get_field(&this, "lenient", "Z").await?; + let lenient: bool = jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await?; Ok((time ^ ((time as u64 >> 32) as i64)) as i32 ^ raw_offset ^ id_hash ^ if lenient { 1 } else { 0 }) } @@ -237,8 +239,8 @@ impl Calendar { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let time: i64 = jvm.get_field(&this, "time", "J").await?; - let other_time: i64 = jvm.get_field(&other, "time", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?; + let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?; Ok(time < other_time) } @@ -250,8 +252,8 @@ impl Calendar { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let time: i64 = jvm.get_field(&this, "time", "J").await?; - let other_time: i64 = jvm.get_field(&other, "time", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?; + let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?; Ok(time > other_time) } @@ -262,7 +264,7 @@ impl Calendar { return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "calendar field").await); } - let mut fields = jvm.get_field(&this, "fields", "[I").await?; + let mut fields = jvm.get_field(&this, "java/util/Calendar", "fields", "[I").await?; jvm.store_array(&mut fields, field as usize, vec![value]).await?; let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeTime", "()V", ()).await?; @@ -278,7 +280,7 @@ impl Calendar { return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "calendar field").await); } - let fields = jvm.get_field(&this, "fields", "[I").await?; + let fields = jvm.get_field(&this, "java/util/Calendar", "fields", "[I").await?; let value = jvm.load_array(&fields, field as usize, 1).await?[0]; Ok(value) diff --git a/rustjava-runtime/src/classes/java/util/collections_copies_list.rs b/rustjava-runtime/src/classes/java/util/collections_copies_list.rs index 184d5032..22accf36 100644 --- a/rustjava-runtime/src/classes/java/util/collections_copies_list.rs +++ b/rustjava-runtime/src/classes/java/util/collections_copies_list.rs @@ -43,19 +43,22 @@ impl CollectionsCopiesList { return Err(jvm.exception("java/lang/IllegalArgumentException", "List length = negative").await); } let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; - jvm.put_field(&mut this, "n", "I", count).await?; - jvm.put_field(&mut this, "element", "Ljava/lang/Object;", element).await + jvm.put_field(&mut this, "java/util/Collections$CopiesList", "n", "I", count).await?; + jvm.put_field(&mut this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;", element) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "n", "I").await + jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - if jvm.get_field::(&this, "n", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/Collections$CopiesList", "n", "I").await? == 0 { return Ok(false); } - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; if target.is_null() { return Ok(element.is_null()); } @@ -67,10 +70,12 @@ impl CollectionsCopiesList { } async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - if jvm.get_field::(&this, "n", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/Collections$CopiesList", "n", "I").await? == 0 { return Ok(-1); } - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; let equal = if target.is_null() { element.is_null() } else if element.is_null() { @@ -83,11 +88,13 @@ impl CollectionsCopiesList { } async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - let count: i32 = jvm.get_field(&this, "n", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await?; if count == 0 { return Ok(-1); } - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; let equal = if target.is_null() { element.is_null() } else if element.is_null() { @@ -100,26 +107,29 @@ impl CollectionsCopiesList { } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let count: i32 = jvm.get_field(&this, "n", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await?; if index < 0 || index >= count { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await); } - jvm.get_field(&this, "element", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - if jvm.get_field::(&this, "n", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/Collections$CopiesList", "n", "I").await? == 0 { return Ok(()); } Err(jvm.exception("java/lang/UnsupportedOperationException", "copies list").await) } async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - let count: i32 = jvm.get_field(&this, "n", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await?; if count == 0 { return Ok(false); } - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; let equal = if target.is_null() { element.is_null() } else if element.is_null() { @@ -163,7 +173,7 @@ impl CollectionsCopiesList { return Ok(false); } - let count: i32 = jvm.get_field(&this, "n", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await?; if jvm .invoke_virtual::<_, i32>(&other, &other.class_definition().name(), "size", "()I", ()) .await? @@ -171,7 +181,9 @@ impl CollectionsCopiesList { { return Ok(false); } - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; let iterator: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ()) .await?; @@ -198,8 +210,10 @@ impl CollectionsCopiesList { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let count: i32 = jvm.get_field(&this, "n", "I").await?; - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let count: i32 = jvm.get_field(&this, "java/util/Collections$CopiesList", "n", "I").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$CopiesList", "element", "Ljava/lang/Object;") + .await?; let element_hash = if element.is_null() { 0 } else { diff --git a/rustjava-runtime/src/classes/java/util/collections_singleton_set.rs b/rustjava-runtime/src/classes/java/util/collections_singleton_set.rs index 720e438c..e067faae 100644 --- a/rustjava-runtime/src/classes/java/util/collections_singleton_set.rs +++ b/rustjava-runtime/src/classes/java/util/collections_singleton_set.rs @@ -35,7 +35,8 @@ impl CollectionsSingletonSet { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "element", "Ljava/lang/Object;", element).await + jvm.put_field(&mut this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;", element) + .await } async fn size(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef) -> Result { @@ -43,7 +44,9 @@ impl CollectionsSingletonSet { } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;") + .await?; if target.is_null() { return Ok(element.is_null()); } @@ -55,7 +58,9 @@ impl CollectionsSingletonSet { } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;") + .await?; let list = jvm .new_class("java/util/Collections$CopiesList", "(ILjava/lang/Object;)V", (1, element)) .await?; @@ -64,7 +69,9 @@ impl CollectionsSingletonSet { } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;") + .await?; let equal = if target.is_null() { element.is_null() } else if element.is_null() { @@ -100,7 +107,9 @@ impl CollectionsSingletonSet { let other_element: ClassInstanceRef = jvm .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ()) .await?; - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;") + .await?; if other_element.is_null() { return Ok(element.is_null()); } @@ -112,7 +121,9 @@ impl CollectionsSingletonSet { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$SingletonSet", "element", "Ljava/lang/Object;") + .await?; if element.is_null() { Ok(0) } else { diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection.rs index e3da8482..d9c50a84 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection.rs @@ -47,23 +47,36 @@ impl CollectionsUnmodifiableCollection { return Err(jvm.exception("java/lang/NullPointerException", "collection").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "c", "Ljava/util/Collection;", collection).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableCollection", + "c", + "Ljava/util/Collection;", + collection, + ) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&collection, &collection.class_definition().name(), "size", "()I", ()) .await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&collection, &collection.class_definition().name(), "isEmpty", "()Z", ()) .await } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual( &collection, &collection.class_definition().name(), @@ -75,7 +88,9 @@ impl CollectionsUnmodifiableCollection { } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; let iterator: ClassInstanceRef = jvm .invoke_virtual( &collection, @@ -92,7 +107,9 @@ impl CollectionsUnmodifiableCollection { } async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ()) .await } @@ -103,7 +120,9 @@ impl CollectionsUnmodifiableCollection { this: ClassInstanceRef, array: ClassInstanceRef>, ) -> Result>> { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual( &collection, &collection.class_definition().name(), @@ -115,7 +134,9 @@ impl CollectionsUnmodifiableCollection { } async fn contains_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, collection: ClassInstanceRef) -> Result { - let backing: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let backing: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual( &backing, &backing.class_definition().name(), @@ -127,7 +148,9 @@ impl CollectionsUnmodifiableCollection { } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let collection: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let collection: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&collection, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection_iterator.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection_iterator.rs index d4a70506..40142cd4 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_collection_iterator.rs @@ -35,17 +35,28 @@ impl CollectionsUnmodifiableCollectionIterator { return Err(jvm.exception("java/lang/NullPointerException", "iterator").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "i", "Ljava/util/Iterator;", iterator).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableCollection$1", + "i", + "Ljava/util/Iterator;", + iterator, + ) + .await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/Iterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection$1", "i", "Ljava/util/Iterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ()) .await } async fn next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/Iterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableCollection$1", "i", "Ljava/util/Iterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list.rs index ae93924d..ece489b8 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list.rs @@ -55,43 +55,56 @@ impl CollectionsUnmodifiableList { (list.clone(),), ) .await?; - jvm.put_field(&mut this, "list", "Ljava/util/List;", list).await + jvm.put_field(&mut this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;", list) + .await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { if !other.is_null() && this.identity() == other.identity() { return Ok(true); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; jvm.invoke_virtual(&list, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other,)) .await } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; jvm.invoke_virtual(&list, "java/lang/Object", "hashCode", "()I", ()).await } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; jvm.invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (index,)) .await } async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; jvm.invoke_virtual(&list, &list.class_definition().name(), "indexOf", "(Ljava/lang/Object;)I", (element,)) .await } async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; jvm.invoke_virtual(&list, &list.class_definition().name(), "lastIndexOf", "(Ljava/lang/Object;)I", (element,)) .await } async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; let iterator: ClassInstanceRef = jvm .invoke_virtual(&list, &list.class_definition().name(), "listIterator", "()Ljava/util/ListIterator;", ()) .await?; @@ -102,7 +115,9 @@ impl CollectionsUnmodifiableList { } async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; let iterator: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -119,7 +134,9 @@ impl CollectionsUnmodifiableList { } async fn sub_list(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, from: i32, to: i32) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/List;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList", "list", "Ljava/util/List;") + .await?; let sub_list: ClassInstanceRef = jvm .invoke_virtual(&list, &list.class_definition().name(), "subList", "(II)Ljava/util/List;", (from, to)) .await?; diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list_iterator.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list_iterator.rs index 03909e89..a09934ca 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_list_iterator.rs @@ -41,41 +41,60 @@ impl CollectionsUnmodifiableListIterator { return Err(jvm.exception("java/lang/NullPointerException", "iterator").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "i", "Ljava/util/ListIterator;", iterator).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableList$1", + "i", + "Ljava/util/ListIterator;", + iterator, + ) + .await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ()) .await } async fn next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ()) .await } async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "hasPrevious", "()Z", ()) .await } async fn previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "previous", "()Ljava/lang/Object;", ()) .await } async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "nextIndex", "()I", ()) .await } async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/ListIterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableList$1", "i", "Ljava/util/ListIterator;") + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "previousIndex", "()I", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map.rs index 22fa3702..8dca3876 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map.rs @@ -62,33 +62,44 @@ impl CollectionsUnmodifiableMap { return Err(jvm.exception("java/lang/NullPointerException", "map").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "m", "Ljava/util/Map;", map).await + jvm.put_field(&mut this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;", map) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "isEmpty", "()Z", ()).await } async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,)) .await } async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "containsValue", "(Ljava/lang/Object;)Z", (value,)) .await } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual( &map, &map.class_definition().name(), @@ -100,11 +111,15 @@ impl CollectionsUnmodifiableMap { } async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cached: ClassInstanceRef = jvm.get_field(&this, "keySet", "Ljava/util/Set;").await?; + let cached: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "keySet", "Ljava/util/Set;") + .await?; if !cached.is_null() { return Ok(cached); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; let keys: ClassInstanceRef = jvm .invoke_virtual(&map, &map.class_definition().name(), "keySet", "()Ljava/util/Set;", ()) .await?; @@ -112,16 +127,27 @@ impl CollectionsUnmodifiableMap { .new_class("java/util/Collections$UnmodifiableSet", "(Ljava/util/Set;)V", (keys,)) .await? .into(); - jvm.put_field(&mut this, "keySet", "Ljava/util/Set;", wrapped.clone()).await?; + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableMap", + "keySet", + "Ljava/util/Set;", + wrapped.clone(), + ) + .await?; Ok(wrapped) } async fn values(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cached: ClassInstanceRef = jvm.get_field(&this, "values", "Ljava/util/Collection;").await?; + let cached: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "values", "Ljava/util/Collection;") + .await?; if !cached.is_null() { return Ok(cached); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; let values: ClassInstanceRef = jvm .invoke_virtual(&map, &map.class_definition().name(), "values", "()Ljava/util/Collection;", ()) .await?; @@ -129,16 +155,27 @@ impl CollectionsUnmodifiableMap { .new_class("java/util/Collections$UnmodifiableCollection", "(Ljava/util/Collection;)V", (values,)) .await? .into(); - jvm.put_field(&mut this, "values", "Ljava/util/Collection;", wrapped.clone()).await?; + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableMap", + "values", + "Ljava/util/Collection;", + wrapped.clone(), + ) + .await?; Ok(wrapped) } async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cached: ClassInstanceRef = jvm.get_field(&this, "entrySet", "Ljava/util/Set;").await?; + let cached: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "entrySet", "Ljava/util/Set;") + .await?; if !cached.is_null() { return Ok(cached); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; let entries: ClassInstanceRef = jvm .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ()) .await?; @@ -150,7 +187,14 @@ impl CollectionsUnmodifiableMap { ) .await? .into(); - jvm.put_field(&mut this, "entrySet", "Ljava/util/Set;", wrapped.clone()).await?; + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableMap", + "entrySet", + "Ljava/util/Set;", + wrapped.clone(), + ) + .await?; Ok(wrapped) } @@ -158,18 +202,24 @@ impl CollectionsUnmodifiableMap { if !other.is_null() && this.identity() == other.identity() { return Ok(true); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other,)) .await } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, "java/lang/Object", "hashCode", "()I", ()).await } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableMap", "m", "Ljava/util/Map;") + .await?; jvm.invoke_virtual(&map, "java/lang/Object", "toString", "()Ljava/lang/String;", ()).await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry.rs index 148f315b..98fe66d6 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry.rs @@ -43,17 +43,38 @@ impl CollectionsUnmodifiableMapEntry { return Err(jvm.exception("java/lang/NullPointerException", "entry").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "e", "Ljava/util/Map$Entry;", entry).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry", + "e", + "Ljava/util/Map$Entry;", + entry, + ) + .await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let entry: ClassInstanceRef = jvm.get_field(&this, "e", "Ljava/util/Map$Entry;").await?; + let entry: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry", + "e", + "Ljava/util/Map$Entry;", + ) + .await?; jvm.invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let entry: ClassInstanceRef = jvm.get_field(&this, "e", "Ljava/util/Map$Entry;").await?; + let entry: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry", + "e", + "Ljava/util/Map$Entry;", + ) + .await?; jvm.invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await } @@ -116,12 +137,26 @@ impl CollectionsUnmodifiableMapEntry { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let entry: ClassInstanceRef = jvm.get_field(&this, "e", "Ljava/util/Map$Entry;").await?; + let entry: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry", + "e", + "Ljava/util/Map$Entry;", + ) + .await?; jvm.invoke_virtual(&entry, "java/lang/Object", "hashCode", "()I", ()).await } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let entry: ClassInstanceRef = jvm.get_field(&this, "e", "Ljava/util/Map$Entry;").await?; + let entry: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry", + "e", + "Ljava/util/Map$Entry;", + ) + .await?; jvm.invoke_virtual(&entry, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set.rs index aabe1417..aa8aff14 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set.rs @@ -40,7 +40,14 @@ impl CollectionsUnmodifiableMapEntrySet { } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet", + "c", + "Ljava/util/Collection;", + ) + .await?; let iterator: ClassInstanceRef = jvm .invoke_virtual(&set, &set.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ()) .await?; @@ -55,7 +62,14 @@ impl CollectionsUnmodifiableMapEntrySet { } async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet", + "c", + "Ljava/util/Collection;", + ) + .await?; let entries: ClassInstanceRef> = jvm .invoke_virtual(&set, &set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ()) .await?; @@ -91,7 +105,14 @@ impl CollectionsUnmodifiableMapEntrySet { let class_definition = destination.class_definition(); let class_name = class_definition.name(); let component_descriptor = class_name.strip_prefix('[').unwrap(); - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet", + "c", + "Ljava/util/Collection;", + ) + .await?; let entries: ClassInstanceRef> = jvm .invoke_virtual(&set, &set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ()) .await?; @@ -140,7 +161,14 @@ impl CollectionsUnmodifiableMapEntrySet { ) .await? .into(); - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet", + "c", + "Ljava/util/Collection;", + ) + .await?; jvm.invoke_virtual(&set, &set.class_definition().name(), "contains", "(Ljava/lang/Object;)Z", (safe,)) .await } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set_iterator.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set_iterator.rs index 026db219..1e08986a 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_map_entry_set_iterator.rs @@ -35,17 +35,38 @@ impl CollectionsUnmodifiableMapEntrySetIterator { return Err(jvm.exception("java/lang/NullPointerException", "iterator").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "i", "Ljava/util/Iterator;", iterator).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1", + "i", + "Ljava/util/Iterator;", + iterator, + ) + .await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/Iterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1", + "i", + "Ljava/util/Iterator;", + ) + .await?; jvm.invoke_virtual(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ()) .await } async fn next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let iterator: ClassInstanceRef = jvm.get_field(&this, "i", "Ljava/util/Iterator;").await?; + let iterator: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1", + "i", + "Ljava/util/Iterator;", + ) + .await?; let entry: ClassInstanceRef = jvm .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ()) .await?; diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_set.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_set.rs index 0cc9b0e0..34a49e10 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_set.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_set.rs @@ -40,13 +40,17 @@ impl CollectionsUnmodifiableSet { if !other.is_null() && this.identity() == other.identity() { return Ok(true); } - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSet", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&set, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other,)) .await } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let set: ClassInstanceRef = jvm.get_field(&this, "c", "Ljava/util/Collection;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSet", "c", "Ljava/util/Collection;") + .await?; jvm.invoke_virtual(&set, "java/lang/Object", "hashCode", "()I", ()).await } } diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_map.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_map.rs index 407bc03f..bdedf7b7 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_map.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_map.rs @@ -58,23 +58,36 @@ impl CollectionsUnmodifiableSortedMap { (map.clone(),), ) .await?; - jvm.put_field(&mut this, "sm", "Ljava/util/SortedMap;", map).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableSortedMap", + "sm", + "Ljava/util/SortedMap;", + map, + ) + .await } async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ()) .await } async fn first_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "firstKey", "()Ljava/lang/Object;", ()) .await } async fn last_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "lastKey", "()Ljava/lang/Object;", ()) .await } @@ -86,7 +99,9 @@ impl CollectionsUnmodifiableSortedMap { from: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -108,7 +123,9 @@ impl CollectionsUnmodifiableSortedMap { this: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -130,7 +147,9 @@ impl CollectionsUnmodifiableSortedMap { this: ClassInstanceRef, from: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "sm", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedMap", "sm", "Ljava/util/SortedMap;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, diff --git a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_set.rs b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_set.rs index a29d240d..fbfdbadb 100644 --- a/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_set.rs +++ b/rustjava-runtime/src/classes/java/util/collections_unmodifiable_sorted_set.rs @@ -58,23 +58,36 @@ impl CollectionsUnmodifiableSortedSet { (set.clone(),), ) .await?; - jvm.put_field(&mut this, "ss", "Ljava/util/SortedSet;", set).await + jvm.put_field( + &mut this, + "java/util/Collections$UnmodifiableSortedSet", + "ss", + "Ljava/util/SortedSet;", + set, + ) + .await } async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; jvm.invoke_virtual(&set, &set.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ()) .await } async fn first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; jvm.invoke_virtual(&set, &set.class_definition().name(), "first", "()Ljava/lang/Object;", ()) .await } async fn last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; jvm.invoke_virtual(&set, &set.class_definition().name(), "last", "()Ljava/lang/Object;", ()) .await } @@ -86,7 +99,9 @@ impl CollectionsUnmodifiableSortedSet { from: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &set, @@ -108,7 +123,9 @@ impl CollectionsUnmodifiableSortedSet { this: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &set, @@ -130,7 +147,9 @@ impl CollectionsUnmodifiableSortedSet { this: ClassInstanceRef, from: ClassInstanceRef, ) -> Result> { - let set: ClassInstanceRef = jvm.get_field(&this, "ss", "Ljava/util/SortedSet;").await?; + let set: ClassInstanceRef = jvm + .get_field(&this, "java/util/Collections$UnmodifiableSortedSet", "ss", "Ljava/util/SortedSet;") + .await?; let range: ClassInstanceRef = jvm .invoke_virtual( &set, diff --git a/rustjava-runtime/src/classes/java/util/date.rs b/rustjava-runtime/src/classes/java/util/date.rs index a721c8e1..c01faf31 100644 --- a/rustjava-runtime/src/classes/java/util/date.rs +++ b/rustjava-runtime/src/classes/java/util/date.rs @@ -53,7 +53,7 @@ impl Date { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "J", time).await?; + jvm.put_field(&mut this, "java/util/Date", "value", "J", time).await?; Ok(()) } @@ -61,7 +61,7 @@ impl Date { async fn get_time(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Date::getTime({this:?})"); - let time = jvm.get_field(&this, "value", "J").await?; + let time = jvm.get_field(&this, "java/util/Date", "value", "J").await?; Ok(time) } @@ -69,7 +69,7 @@ impl Date { async fn set_time(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, time: i64) -> Result<()> { tracing::debug!("java.util.Date::setTime({this:?}, {time:?})"); - jvm.put_field(&mut this, "value", "J", time).await?; + jvm.put_field(&mut this, "java/util/Date", "value", "J", time).await?; Ok(()) } @@ -82,8 +82,8 @@ impl Date { } let when: ClassInstanceRef = ClassInstanceRef::new(when.instance); - let time: i64 = jvm.get_field(&this, "value", "J").await?; - let when_time: i64 = jvm.get_field(&when, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; + let when_time: i64 = jvm.get_field(&when, "java/util/Date", "value", "J").await?; Ok(time < when_time) } @@ -95,8 +95,8 @@ impl Date { } let when: ClassInstanceRef = ClassInstanceRef::new(when.instance); - let time: i64 = jvm.get_field(&this, "value", "J").await?; - let when_time: i64 = jvm.get_field(&when, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; + let when_time: i64 = jvm.get_field(&when, "java/util/Date", "value", "J").await?; Ok(time > when_time) } @@ -111,8 +111,8 @@ impl Date { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let time: i64 = jvm.get_field(&this, "value", "J").await?; - let other_time: i64 = jvm.get_field(&other, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; + let other_time: i64 = jvm.get_field(&other, "java/util/Date", "value", "J").await?; Ok(if time < other_time { -1 } else if time == other_time { @@ -130,22 +130,22 @@ impl Date { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let time: i64 = jvm.get_field(&this, "value", "J").await?; - let other_time: i64 = jvm.get_field(&other, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; + let other_time: i64 = jvm.get_field(&other, "java/util/Date", "value", "J").await?; Ok(time == other_time) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Date::hashCode({this:?})"); - let time: i64 = jvm.get_field(&this, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; Ok((time ^ ((time as u64 >> 32) as i64)) as i32) } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Date::toString({this:?})"); - let time: i64 = jvm.get_field(&this, "value", "J").await?; + let time: i64 = jvm.get_field(&this, "java/util/Date", "value", "J").await?; let text = if let Some(date_time) = DateTime::::from_timestamp_millis(time) { let weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; let months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; diff --git a/rustjava-runtime/src/classes/java/util/duplicate_format_flags_exception.rs b/rustjava-runtime/src/classes/java/util/duplicate_format_flags_exception.rs index a3a74c61..ae03d6fe 100644 --- a/rustjava-runtime/src/classes/java/util/duplicate_format_flags_exception.rs +++ b/rustjava-runtime/src/classes/java/util/duplicate_format_flags_exception.rs @@ -30,15 +30,19 @@ impl DuplicateFormatFlagsException { return Err(jvm.exception("java/lang/NullPointerException", "flags is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "flags", "Ljava/lang/String;", flags).await + jvm.put_field(&mut this, "java/util/DuplicateFormatFlagsException", "flags", "Ljava/lang/String;", flags) + .await } async fn get_flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "flags", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/DuplicateFormatFlagsException", "flags", "Ljava/lang/String;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let flags: ClassInstanceRef = jvm.get_field(&this, "flags", "Ljava/lang/String;").await?; + let flags: ClassInstanceRef = jvm + .get_field(&this, "java/util/DuplicateFormatFlagsException", "flags", "Ljava/lang/String;") + .await?; JavaLangString::from_rust_string(jvm, &alloc::format!("Flags = '{}'", JavaLangString::to_rust_string(jvm, &flags).await?)) .await .map(Into::into) diff --git a/rustjava-runtime/src/classes/java/util/format_flags_conversion_mismatch_exception.rs b/rustjava-runtime/src/classes/java/util/format_flags_conversion_mismatch_exception.rs index c8d5d0e5..21ce04d8 100644 --- a/rustjava-runtime/src/classes/java/util/format_flags_conversion_mismatch_exception.rs +++ b/rustjava-runtime/src/classes/java/util/format_flags_conversion_mismatch_exception.rs @@ -40,21 +40,41 @@ impl FormatFlagsConversionMismatchException { return Err(jvm.exception("java/lang/NullPointerException", "flags is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "flags", "Ljava/lang/String;", flags).await?; - jvm.put_field(&mut this, "conversion", "C", conversion).await + jvm.put_field( + &mut this, + "java/util/FormatFlagsConversionMismatchException", + "flags", + "Ljava/lang/String;", + flags, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/FormatFlagsConversionMismatchException", + "conversion", + "C", + conversion, + ) + .await } async fn get_flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "flags", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/FormatFlagsConversionMismatchException", "flags", "Ljava/lang/String;") + .await } async fn get_conversion(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "conversion", "C").await + jvm.get_field(&this, "java/util/FormatFlagsConversionMismatchException", "conversion", "C") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let flags: ClassInstanceRef = jvm.get_field(&this, "flags", "Ljava/lang/String;").await?; - let conversion: JavaChar = jvm.get_field(&this, "conversion", "C").await?; + let flags: ClassInstanceRef = jvm + .get_field(&this, "java/util/FormatFlagsConversionMismatchException", "flags", "Ljava/lang/String;") + .await?; + let conversion: JavaChar = jvm + .get_field(&this, "java/util/FormatFlagsConversionMismatchException", "conversion", "C") + .await?; Ok(JavaLangString::from_rust_string( jvm, &format!( diff --git a/rustjava-runtime/src/classes/java/util/formatter.rs b/rustjava-runtime/src/classes/java/util/formatter.rs index 77beae01..acfe9e42 100644 --- a/rustjava-runtime/src/classes/java/util/formatter.rs +++ b/rustjava-runtime/src/classes/java/util/formatter.rs @@ -185,10 +185,12 @@ impl Formatter { } else { appendable }; - jvm.put_field(&mut this, "a", "Ljava/lang/Appendable;", appendable).await?; - jvm.put_field(&mut this, "l", "Ljava/util/Locale;", locale).await?; + jvm.put_field(&mut this, "java/util/Formatter", "a", "Ljava/lang/Appendable;", appendable) + .await?; + jvm.put_field(&mut this, "java/util/Formatter", "l", "Ljava/util/Locale;", locale).await?; jvm.put_field( &mut this, + "java/util/Formatter", "lastException", "Ljava/io/IOException;", ClassInstanceRef::::new(None), @@ -401,11 +403,11 @@ impl Formatter { let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ()) .await?; - jvm.get_field(&this, "l", "Ljava/util/Locale;").await + jvm.get_field(&this, "java/util/Formatter", "l", "Ljava/util/Locale;").await } async fn out(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let appendable: ClassInstanceRef = jvm.get_field(&this, "a", "Ljava/lang/Appendable;").await?; + let appendable: ClassInstanceRef = jvm.get_field(&this, "java/util/Formatter", "a", "Ljava/lang/Appendable;").await?; if appendable.is_null() { return Err(JavaError::JavaException( jvm.new_class("java/util/FormatterClosedException", "()V", ()).await?, @@ -437,6 +439,7 @@ impl Formatter { Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { jvm.put_field( &mut this, + "java/util/Formatter", "lastException", "Ljava/io/IOException;", ClassInstanceRef::::from(exception), @@ -448,7 +451,7 @@ impl Formatter { } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let appendable: ClassInstanceRef = jvm.get_field(&this, "a", "Ljava/lang/Appendable;").await?; + let appendable: ClassInstanceRef = jvm.get_field(&this, "java/util/Formatter", "a", "Ljava/lang/Appendable;").await?; if appendable.is_null() { return Ok(()); } @@ -458,13 +461,20 @@ impl Formatter { } else { Ok(()) }; - jvm.put_field(&mut this, "a", "Ljava/lang/Appendable;", ClassInstanceRef::::new(None)) - .await?; + jvm.put_field( + &mut this, + "java/util/Formatter", + "a", + "Ljava/lang/Appendable;", + ClassInstanceRef::::new(None), + ) + .await?; match result { Ok(()) => Ok(()), Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { jvm.put_field( &mut this, + "java/util/Formatter", "lastException", "Ljava/io/IOException;", ClassInstanceRef::::from(exception), @@ -476,7 +486,8 @@ impl Formatter { } async fn io_exception(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "lastException", "Ljava/io/IOException;").await + jvm.get_field(&this, "java/util/Formatter", "lastException", "Ljava/io/IOException;") + .await } async fn append_output(jvm: &Jvm, this: &mut ClassInstanceRef, characters: Vec) -> Result<()> { @@ -501,6 +512,7 @@ impl Formatter { Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => { jvm.put_field( this, + "java/util/Formatter", "lastException", "Ljava/io/IOException;", ClassInstanceRef::::from(exception), @@ -518,7 +530,7 @@ impl Formatter { format: ClassInstanceRef, arguments: ClassInstanceRef>, ) -> Result> { - let locale: ClassInstanceRef = jvm.get_field(&this, "l", "Ljava/util/Locale;").await?; + let locale: ClassInstanceRef = jvm.get_field(&this, "java/util/Formatter", "l", "Ljava/util/Locale;").await?; jvm.invoke_virtual( &this, "java/util/Formatter", @@ -925,7 +937,8 @@ impl Formatter { if specifier.flags.contains(&'#') { flags |= 4; } - let formatter_locale: ClassInstanceRef = jvm.get_field(formatter, "l", "Ljava/util/Locale;").await?; + let formatter_locale: ClassInstanceRef = + jvm.get_field(formatter, "java/util/Formatter", "l", "Ljava/util/Locale;").await?; let callback_formatter = if (formatter_locale.is_null() && locale.is_null()) || (!formatter_locale.is_null() && !locale.is_null() && formatter_locale.identity() == locale.identity()) { diff --git a/rustjava-runtime/src/classes/java/util/gregorian_calendar.rs b/rustjava-runtime/src/classes/java/util/gregorian_calendar.rs index e87b4c66..199cb53b 100644 --- a/rustjava-runtime/src/classes/java/util/gregorian_calendar.rs +++ b/rustjava-runtime/src/classes/java/util/gregorian_calendar.rs @@ -32,7 +32,8 @@ impl GregorianCalendar { tracing::debug!("java.util.GregorianCalendar::({this:?})"); let _: () = jvm.invoke_special(&this, "java/util/Calendar", "", "()V", ()).await?; - jvm.put_field(&mut this, "time", "J", context.now() as i64).await?; + jvm.put_field(&mut this, "java/util/GregorianCalendar", "time", "J", context.now() as i64) + .await?; jvm.invoke_virtual(&this, "java/util/GregorianCalendar", "computeFields", "()V", ()).await } @@ -49,8 +50,10 @@ impl GregorianCalendar { } let _: () = jvm.invoke_special(&this, "java/util/Calendar", "", "()V", ()).await?; - jvm.put_field(&mut this, "timeZone", "Ljava/util/TimeZone;", time_zone).await?; - jvm.put_field(&mut this, "time", "J", context.now() as i64).await?; + jvm.put_field(&mut this, "java/util/GregorianCalendar", "timeZone", "Ljava/util/TimeZone;", time_zone) + .await?; + jvm.put_field(&mut this, "java/util/GregorianCalendar", "time", "J", context.now() as i64) + .await?; jvm.invoke_virtual(&this, "java/util/GregorianCalendar", "computeFields", "()V", ()).await } @@ -59,7 +62,7 @@ impl GregorianCalendar { // fields -> time - let fields = jvm.get_field(&this, "fields", "[I").await?; + let fields = jvm.get_field(&this, "java/util/GregorianCalendar", "fields", "[I").await?; // TODO constant let fields: Vec = jvm.load_array(&fields, 0, 17).await?; @@ -96,7 +99,8 @@ impl GregorianCalendar { return Err(jvm.exception("java/lang/IllegalArgumentException", "calendar time out of range").await); }; - jvm.put_field(&mut this, "time", "J", calculated_time).await?; + jvm.put_field(&mut this, "java/util/GregorianCalendar", "time", "J", calculated_time) + .await?; Ok(()) } @@ -106,8 +110,10 @@ impl GregorianCalendar { // time -> fields - let time: i64 = jvm.get_field(&this, "time", "J").await?; - let time_zone: ClassInstanceRef = jvm.get_field(&this, "timeZone", "Ljava/util/TimeZone;").await?; + let time: i64 = jvm.get_field(&this, "java/util/GregorianCalendar", "time", "J").await?; + let time_zone: ClassInstanceRef = jvm + .get_field(&this, "java/util/GregorianCalendar", "timeZone", "Ljava/util/TimeZone;") + .await?; let zone_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?; let Some(adjusted_time) = time.checked_add(zone_offset as i64) else { return Err(jvm.exception("java/lang/IllegalArgumentException", "calendar time out of range").await); @@ -136,7 +142,7 @@ impl GregorianCalendar { 0, ]; - let mut fields = jvm.get_field(&this, "fields", "[I").await?; + let mut fields = jvm.get_field(&this, "java/util/GregorianCalendar", "fields", "[I").await?; jvm.store_array(&mut fields, 0, calculated_fields).await?; Ok(()) diff --git a/rustjava-runtime/src/classes/java/util/hash_map.rs b/rustjava-runtime/src/classes/java/util/hash_map.rs index 61e9f93b..75c3d1cd 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map.rs @@ -167,12 +167,19 @@ impl HashMap { let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "", "()V", ()).await?; let table: ClassInstanceRef> = jvm.instantiate_array("Ljava/util/HashMap$Entry;", capacity as usize).await?.into(); - jvm.put_field(&mut this, "table", "[Ljava/util/HashMap$Entry;", table).await?; - jvm.put_field(&mut this, "size", "I", 0).await?; - jvm.put_field(&mut this, "threshold", "I", Self::threshold_for_capacity(capacity, load_factor)) + jvm.put_field(&mut this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;", table) .await?; - jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?; - jvm.put_field(&mut this, "modCount", "I", 0).await?; + jvm.put_field(&mut this, "java/util/HashMap", "size", "I", 0).await?; + jvm.put_field( + &mut this, + "java/util/HashMap", + "threshold", + "I", + Self::threshold_for_capacity(capacity, load_factor), + ) + .await?; + jvm.put_field(&mut this, "java/util/HashMap", "loadFactor", "F", load_factor).await?; + jvm.put_field(&mut this, "java/util/HashMap", "modCount", "I", 0).await?; let _: () = jvm.invoke_virtual(&this, "java/util/HashMap", "initializeMap", "()V", ()).await?; Ok(()) @@ -212,13 +219,13 @@ impl HashMap { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap::size({this:?})"); - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "java/util/HashMap", "size", "I").await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap::isEmpty({this:?})"); - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/HashMap", "size", "I").await?; Ok(size == 0) } @@ -234,17 +241,19 @@ impl HashMap { async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap::containsValue({this:?}, {value:?})"); - let table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(&this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; if Self::object_equals(jvm, &value, &entry_value).await? { return Ok(true); } - entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; } } @@ -259,7 +268,7 @@ impl HashMap { return Ok(None.into()); } - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await } async fn put( @@ -274,18 +283,19 @@ impl HashMap { let key_hash = Self::object_hash_or_zero(jvm, &key).await?; Self::ensure_table_for_insert(jvm, &mut this).await?; - let table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(&this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; let bucket_index = Self::bucket_index(key_hash, table_len); let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/HashMap$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; if Self::keys_equal(jvm, &key, &entry_key).await? { - let old_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?; + let old_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; let _: () = jvm .invoke_virtual(&entry, "java/util/HashMap$Entry", "onAccess", "(Ljava/util/HashMap;)V", (this.clone(),)) .await?; @@ -293,7 +303,9 @@ impl HashMap { } } - entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; } let _: () = jvm @@ -325,7 +337,8 @@ impl HashMap { tracing::debug!("java.util.HashMap::remove({this:?}, {key:?})"); let key_hash = Self::object_hash_or_zero(jvm, &key).await?; - let mut table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let mut table: ClassInstanceRef> = + jvm.get_field(&this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; if table_len == 0 { return Ok(None.into()); @@ -335,35 +348,48 @@ impl HashMap { let mut previous: ClassInstanceRef = None.into(); let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/HashMap$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; if Self::keys_equal(jvm, &key, &entry_key).await? { - let next: ClassInstanceRef = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; + let next: ClassInstanceRef = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; if previous.is_null() { jvm.store_array(&mut table, bucket_index, core::iter::once(next.clone())).await?; } else { - jvm.put_field(&mut previous, "next", "Ljava/util/HashMap$Entry;", next.clone()).await?; + jvm.put_field( + &mut previous, + "java/util/HashMap$Entry", + "next", + "Ljava/util/HashMap$Entry;", + next.clone(), + ) + .await?; } - let old_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let old_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; let _: () = jvm .invoke_virtual(&entry, "java/util/HashMap$Entry", "onRemoval", "(Ljava/util/HashMap;)V", (this.clone(),)) .await?; let null_entry: ClassInstanceRef = None.into(); - jvm.put_field(&mut entry, "next", "Ljava/util/HashMap$Entry;", null_entry).await?; + jvm.put_field(&mut entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;", null_entry) + .await?; - let size: i32 = jvm.get_field(&this, "size", "I").await?; - jvm.put_field(&mut this, "size", "I", size - 1).await?; - let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?; - jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?; + let size: i32 = jvm.get_field(&this, "java/util/HashMap", "size", "I").await?; + jvm.put_field(&mut this, "java/util/HashMap", "size", "I", size - 1).await?; + let mod_count: i32 = jvm.get_field(&this, "java/util/HashMap", "modCount", "I").await?; + jvm.put_field(&mut this, "java/util/HashMap", "modCount", "I", mod_count.wrapping_add(1)) + .await?; return Ok(old_value); } } previous = entry; - entry = jvm.get_field(&previous, "next", "Ljava/util/HashMap$Entry;").await?; + entry = jvm + .get_field(&previous, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; } Ok(None.into()) @@ -372,15 +398,17 @@ impl HashMap { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.HashMap::clear({this:?})"); - let mut table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let mut table: ClassInstanceRef> = + jvm.get_field(&this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; if table_len > 0 { let nulls: Vec> = (0..table_len).map(|_| None.into()).collect(); jvm.store_array(&mut table, 0, nulls).await?; } - jvm.put_field(&mut this, "size", "I", 0).await?; - let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?; - jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?; + jvm.put_field(&mut this, "java/util/HashMap", "size", "I", 0).await?; + let mod_count: i32 = jvm.get_field(&this, "java/util/HashMap", "modCount", "I").await?; + jvm.put_field(&mut this, "java/util/HashMap", "modCount", "I", mod_count.wrapping_add(1)) + .await?; Ok(()) } @@ -398,7 +426,8 @@ impl HashMap { value: ClassInstanceRef, bucket_index: i32, ) -> Result<()> { - let mut table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let mut table: ClassInstanceRef> = + jvm.get_field(&this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let existing = Self::load_bucket(jvm, &table, bucket_index as usize).await?; let entry: ClassInstanceRef = jvm .new_class( @@ -409,8 +438,8 @@ impl HashMap { .await? .into(); jvm.store_array(&mut table, bucket_index as usize, core::iter::once(entry)).await?; - let size: i32 = jvm.get_field(&this, "size", "I").await?; - jvm.put_field(&mut this, "size", "I", size + 1).await + let size: i32 = jvm.get_field(&this, "java/util/HashMap", "size", "I").await?; + jvm.put_field(&mut this, "java/util/HashMap", "size", "I", size + 1).await } async fn insert_new_entry( @@ -422,9 +451,10 @@ impl HashMap { value: ClassInstanceRef, bucket_index: i32, ) -> Result<()> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; - let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?; - jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?; + let size: i32 = jvm.get_field(&this, "java/util/HashMap", "size", "I").await?; + let mod_count: i32 = jvm.get_field(&this, "java/util/HashMap", "modCount", "I").await?; + jvm.put_field(&mut this, "java/util/HashMap", "modCount", "I", mod_count.wrapping_add(1)) + .await?; let _: () = jvm .invoke_virtual( &this, @@ -434,7 +464,7 @@ impl HashMap { (hash, key, value, bucket_index), ) .await?; - let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?; + let threshold: i32 = jvm.get_field(&this, "java/util/HashMap", "threshold", "I").await?; if size >= threshold { Self::rehash(jvm, &mut this).await?; } @@ -475,7 +505,7 @@ impl HashMap { key: &ClassInstanceRef, ) -> Result> { let key_hash = Self::object_hash_or_zero(jvm, key).await?; - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; if table_len == 0 { return Ok(None.into()); @@ -484,15 +514,17 @@ impl HashMap { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/HashMap$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; if Self::keys_equal(jvm, key, &entry_key).await? { return Ok(entry); } } - entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; } Ok(None.into()) @@ -506,7 +538,7 @@ impl HashMap { ) -> Result<()> { let hash = Self::object_hash_or_zero(jvm, &key).await?; Self::ensure_table_for_insert(jvm, this).await?; - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let bucket_index = Self::bucket_index(hash, jvm.array_length(&table).await?); jvm.invoke_virtual( this, @@ -519,23 +551,31 @@ impl HashMap { } async fn ensure_table_for_insert(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; if jvm.array_length(&table).await? > 0 { return Ok(()); } let new_capacity = 1; let new_table: ClassInstanceRef> = jvm.instantiate_array("Ljava/util/HashMap$Entry;", new_capacity).await?.into(); - jvm.put_field(this, "table", "[Ljava/util/HashMap$Entry;", new_table).await?; - let load_factor: f32 = jvm.get_field(this, "loadFactor", "F").await?; - jvm.put_field(this, "threshold", "I", Self::threshold_for_capacity(new_capacity as i32, load_factor)) + jvm.put_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;", new_table) .await?; + let load_factor: f32 = jvm.get_field(this, "java/util/HashMap", "loadFactor", "F").await?; + jvm.put_field( + this, + "java/util/HashMap", + "threshold", + "I", + Self::threshold_for_capacity(new_capacity as i32, load_factor), + ) + .await?; Ok(()) } pub(super) async fn rehash(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let old_table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?; + let old_table: ClassInstanceRef> = + jvm.get_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let old_capacity = jvm.array_length(&old_table).await?; let new_capacity = old_capacity * 2 + 1; @@ -543,22 +583,32 @@ impl HashMap { for bucket_index in 0..old_capacity { let mut entry = Self::load_bucket(jvm, &old_table, bucket_index).await?; while !entry.is_null() { - let next: ClassInstanceRef = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let next: ClassInstanceRef = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/HashMap$Entry", "hash", "I").await?; let new_index = Self::bucket_index(entry_hash, new_capacity); let existing = Self::load_bucket(jvm, &new_table, new_index).await?; - jvm.put_field(&mut entry, "next", "Ljava/util/HashMap$Entry;", existing).await?; + jvm.put_field(&mut entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;", existing) + .await?; jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?; entry = next; } } - jvm.put_field(this, "table", "[Ljava/util/HashMap$Entry;", new_table).await?; - let load_factor: f32 = jvm.get_field(this, "loadFactor", "F").await?; - jvm.put_field(this, "threshold", "I", Self::threshold_for_capacity(new_capacity as i32, load_factor)) + jvm.put_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;", new_table) .await?; + let load_factor: f32 = jvm.get_field(this, "java/util/HashMap", "loadFactor", "F").await?; + jvm.put_field( + this, + "java/util/HashMap", + "threshold", + "I", + Self::threshold_for_capacity(new_capacity as i32, load_factor), + ) + .await?; Ok(()) } @@ -606,22 +656,24 @@ impl HashMap { } async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef, kind: SnapshotKind) -> Result>> { - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(this, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; let table_len = jvm.array_length(&table).await?; - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/HashMap", "size", "I").await?; let mut elements: Vec> = Vec::with_capacity(size as usize); for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { let element = match kind { - SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?, - SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?, + SnapshotKind::Keys => jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?, + SnapshotKind::Values => jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?, SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance), }; elements.push(element); - entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;") + .await?; } } diff --git a/rustjava-runtime/src/classes/java/util/hash_map_entry.rs b/rustjava-runtime/src/classes/java/util/hash_map_entry.rs index bb69090e..994f1d54 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map_entry.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map_entry.rs @@ -60,10 +60,13 @@ impl HashMapEntry { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "hash", "I", hash).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "next", "Ljava/util/HashMap$Entry;", next).await?; + jvm.put_field(&mut this, "java/util/HashMap$Entry", "hash", "I", hash).await?; + jvm.put_field(&mut this, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;", key) + .await?; + jvm.put_field(&mut this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; + jvm.put_field(&mut this, "java/util/HashMap$Entry", "next", "Ljava/util/HashMap$Entry;", next) + .await?; Ok(()) } @@ -71,13 +74,13 @@ impl HashMapEntry { async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$Entry::getKey({this:?})"); - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$Entry::getValue({this:?})"); - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -88,8 +91,9 @@ impl HashMapEntry { ) -> Result> { tracing::debug!("java.util.HashMap$Entry::setValue({this:?}, {value:?})"); - let old_value = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old_value = jvm.get_field(&this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; Ok(old_value) } @@ -99,7 +103,7 @@ impl HashMapEntry { return Ok(false); } - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; let other_key: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await?; @@ -113,7 +117,7 @@ impl HashMapEntry { return Ok(false); } - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; let other_value: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; @@ -126,8 +130,8 @@ impl HashMapEntry { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; let key_hash = if key.is_null() { 0 } else { diff --git a/rustjava-runtime/src/classes/java/util/hash_map_entry_set.rs b/rustjava-runtime/src/classes/java/util/hash_map_entry_set.rs index c945632e..57c7cd89 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map_entry_set.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map_entry_set.rs @@ -45,7 +45,8 @@ impl HashMapEntrySet { tracing::debug!("java.util.HashMap$EntrySet::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/HashMap;", map).await?; + jvm.put_field(&mut this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;", map) + .await?; Ok(()) } @@ -53,7 +54,7 @@ impl HashMapEntrySet { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$EntrySet::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "size", "()I", ()).await } @@ -61,7 +62,7 @@ impl HashMapEntrySet { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$EntrySet::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "isEmpty", "()Z", ()).await } @@ -73,7 +74,7 @@ impl HashMapEntrySet { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; let candidate_key: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await?; @@ -83,7 +84,7 @@ impl HashMapEntrySet { return Ok(false); } - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; if !Self::object_equals(jvm, &entry_key, &candidate_key).await? { return Ok(false); } @@ -91,7 +92,7 @@ impl HashMapEntrySet { let candidate_value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; Self::object_equals(jvm, &entry_value, &candidate_value).await } @@ -103,7 +104,7 @@ impl HashMapEntrySet { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; let candidate_key: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await?; @@ -112,7 +113,7 @@ impl HashMapEntrySet { return Ok(false); } - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?; if !Self::object_equals(jvm, &entry_key, &candidate_key).await? { return Ok(false); } @@ -120,7 +121,7 @@ impl HashMapEntrySet { let candidate_value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await?; if !Self::object_equals(jvm, &entry_value, &candidate_value).await? { return Ok(false); } @@ -141,7 +142,7 @@ impl HashMapEntrySet { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.HashMap$EntrySet::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "clear", "()V", ()).await } @@ -149,7 +150,7 @@ impl HashMapEntrySet { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$EntrySet::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$EntrySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "entryIterator", "()Ljava/util/Iterator;", ()) .await diff --git a/rustjava-runtime/src/classes/java/util/hash_map_hash_iterator.rs b/rustjava-runtime/src/classes/java/util/hash_map_hash_iterator.rs index c97886a1..6869064d 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map_hash_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map_hash_iterator.rs @@ -34,8 +34,9 @@ impl HashMapHashIterator { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "elements", "[Ljava/lang/Object;", elements).await?; - jvm.put_field(&mut this, "index", "I", 0).await?; + jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;", elements) + .await?; + jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "index", "I", 0).await?; Ok(()) } @@ -43,8 +44,10 @@ impl HashMapHashIterator { async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$HashIterator::hasNext({this:?})"); - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm + .get_field(&this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;") + .await?; + let index: i32 = jvm.get_field(&this, "java/util/HashMap$HashIterator", "index", "I").await?; if index < 0 { return Ok(false); } @@ -55,8 +58,10 @@ impl HashMapHashIterator { async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$HashIterator::next({this:?})"); - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm + .get_field(&this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;") + .await?; + let index: i32 = jvm.get_field(&this, "java/util/HashMap$HashIterator", "index", "I").await?; if index < 0 || index as usize >= jvm.array_length(&elements).await? { return Err(jvm.exception("java/util/NoSuchElementException", "HashMap iterator exhausted").await); } @@ -65,7 +70,8 @@ impl HashMapHashIterator { let Some(element) = values.pop() else { return Err(jvm.exception("java/util/NoSuchElementException", "HashMap iterator exhausted").await); }; - jvm.put_field(&mut this, "index", "I", index + 1).await?; + jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "index", "I", index + 1) + .await?; Ok(element) } diff --git a/rustjava-runtime/src/classes/java/util/hash_map_key_set.rs b/rustjava-runtime/src/classes/java/util/hash_map_key_set.rs index 66eb8eb5..cd79370e 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map_key_set.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map_key_set.rs @@ -50,7 +50,8 @@ impl HashMapKeySet { tracing::debug!("java.util.HashMap$KeySet::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/HashMap;", map).await?; + jvm.put_field(&mut this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;", map) + .await?; Ok(()) } @@ -58,7 +59,7 @@ impl HashMapKeySet { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$KeySet::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "size", "()I", ()).await } @@ -66,7 +67,7 @@ impl HashMapKeySet { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$KeySet::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "isEmpty", "()Z", ()).await } @@ -74,7 +75,7 @@ impl HashMapKeySet { async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$KeySet::contains({this:?}, {key:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "containsKey", "(Ljava/lang/Object;)Z", (key,)) .await @@ -83,7 +84,7 @@ impl HashMapKeySet { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$KeySet::remove({this:?}, {key:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; let contains: bool = jvm .invoke_virtual(&map, "java/util/HashMap", "containsKey", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; @@ -101,7 +102,7 @@ impl HashMapKeySet { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.HashMap$KeySet::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "clear", "()V", ()).await } @@ -109,7 +110,7 @@ impl HashMapKeySet { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$KeySet::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$KeySet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "keyIterator", "()Ljava/util/Iterator;", ()) .await diff --git a/rustjava-runtime/src/classes/java/util/hash_map_values.rs b/rustjava-runtime/src/classes/java/util/hash_map_values.rs index 9585b09c..a7ce7b18 100644 --- a/rustjava-runtime/src/classes/java/util/hash_map_values.rs +++ b/rustjava-runtime/src/classes/java/util/hash_map_values.rs @@ -45,7 +45,8 @@ impl HashMapValues { tracing::debug!("java.util.HashMap$Values::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/HashMap;", map).await?; + jvm.put_field(&mut this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;", map) + .await?; Ok(()) } @@ -53,7 +54,7 @@ impl HashMapValues { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$Values::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "size", "()I", ()).await } @@ -61,7 +62,7 @@ impl HashMapValues { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$Values::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "isEmpty", "()Z", ()).await } @@ -69,7 +70,7 @@ impl HashMapValues { async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$Values::contains({this:?}, {value:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "containsValue", "(Ljava/lang/Object;)Z", (value,)) .await @@ -78,7 +79,7 @@ impl HashMapValues { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashMap$Values::remove({this:?}, {value:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; let iterator: ClassInstanceRef = jvm .invoke_virtual(&map, "java/util/HashMap", "entryIterator", "()Ljava/util/Iterator;", ()) .await?; @@ -117,7 +118,7 @@ impl HashMapValues { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.HashMap$Values::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "clear", "()V", ()).await } @@ -125,7 +126,7 @@ impl HashMapValues { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.HashMap$Values::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashMap$Values", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "valueIterator", "()Ljava/util/Iterator;", ()) .await diff --git a/rustjava-runtime/src/classes/java/util/hash_set.rs b/rustjava-runtime/src/classes/java/util/hash_set.rs index f71ea793..ef316112 100644 --- a/rustjava-runtime/src/classes/java/util/hash_set.rs +++ b/rustjava-runtime/src/classes/java/util/hash_set.rs @@ -63,8 +63,9 @@ impl HashSet { let map: ClassInstanceRef = jvm.new_class("java/util/HashMap", "(I)V", (capacity,)).await?.into(); let present: ClassInstanceRef = jvm.new_class("java/lang/Object", "()V", ()).await?.into(); - jvm.put_field(&mut this, "map", "Ljava/util/HashMap;", map).await?; - jvm.put_field(&mut this, "present", "Ljava/lang/Object;", present).await?; + jvm.put_field(&mut this, "java/util/HashSet", "map", "Ljava/util/HashMap;", map).await?; + jvm.put_field(&mut this, "java/util/HashSet", "present", "Ljava/lang/Object;", present) + .await?; Ok(()) } @@ -95,8 +96,8 @@ impl HashSet { async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashSet::add({this:?}, {element:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; - let present: ClassInstanceRef = jvm.get_field(&this, "present", "Ljava/lang/Object;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; + let present: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "present", "Ljava/lang/Object;").await?; let old: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -113,7 +114,7 @@ impl HashSet { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashSet::remove({this:?}, {element:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; let old: ClassInstanceRef = jvm .invoke_virtual(&map, "java/util/HashMap", "remove", "(Ljava/lang/Object;)Ljava/lang/Object;", (element,)) .await?; @@ -124,7 +125,7 @@ impl HashSet { async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashSet::contains({this:?}, {element:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "containsKey", "(Ljava/lang/Object;)Z", (element,)) .await @@ -133,7 +134,7 @@ impl HashSet { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashSet::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "size", "()I", ()).await } @@ -141,7 +142,7 @@ impl HashSet { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.HashSet::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "isEmpty", "()Z", ()).await } @@ -149,7 +150,7 @@ impl HashSet { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.HashSet::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "clear", "()V", ()).await } @@ -173,7 +174,7 @@ impl HashSet { } async fn key_set(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(this, "map", "Ljava/util/HashMap;").await?; + let map: ClassInstanceRef = jvm.get_field(this, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; jvm.invoke_virtual(&map, "java/util/HashMap", "keySet", "()Ljava/util/Set;", ()).await } diff --git a/rustjava-runtime/src/classes/java/util/hashtable.rs b/rustjava-runtime/src/classes/java/util/hashtable.rs index b640cde2..ad8d7853 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable.rs @@ -139,11 +139,19 @@ impl Hashtable { let initial_capacity = initial_capacity.max(1); let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", initial_capacity as usize).await?; - jvm.put_field(&mut this, "table", "[Ljava/util/Hashtable$Entry;", table).await?; - jvm.put_field(&mut this, "count", "I", 0).await?; - jvm.put_field(&mut this, "threshold", "I", (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32) + jvm.put_field(&mut this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", table) + .await?; + jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?; + jvm.put_field( + &mut this, + "java/util/Hashtable", + "threshold", + "I", + (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32, + ) + .await?; + jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", DEFAULT_LOAD_FACTOR) .await?; - jvm.put_field(&mut this, "loadFactor", "F", DEFAULT_LOAD_FACTOR).await?; Ok(()) } @@ -193,13 +201,13 @@ impl Hashtable { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable::size({this:?})"); - jvm.get_field(&this, "count", "I").await + jvm.get_field(&this, "java/util/Hashtable", "count", "I").await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable::isEmpty({this:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?; Ok(count == 0) } @@ -208,15 +216,17 @@ impl Hashtable { tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})"); let key_hash = Self::key_hash(jvm, &key).await?; - let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await? as i32; let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize; let mut entry: ClassInstanceRef = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap(); while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let equals: bool = jvm .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; @@ -224,7 +234,9 @@ impl Hashtable { return Ok(true); } } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } Ok(false) @@ -237,17 +249,21 @@ impl Hashtable { return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await); } - let table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; if Self::object_equals(jvm, &value, &entry_value).await? { return Ok(true); } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } } @@ -258,23 +274,27 @@ impl Hashtable { tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})"); let key_hash = Self::key_hash(jvm, &key).await?; - let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await? as i32; let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize; let mut entry: ClassInstanceRef = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap(); while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let equals: bool = jvm .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; if equals { - return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await; + return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await; } } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } Ok(None.into()) @@ -289,7 +309,9 @@ impl Hashtable { tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})"); let key_hash = Self::key_hash(jvm, &key).await?; - let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let mut table = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await? as i32; let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize; @@ -297,28 +319,33 @@ impl Hashtable { let mut entry: ClassInstanceRef = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap(); while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let equals: bool = jvm .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; if equals { - let next: ClassInstanceRef = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + let next: ClassInstanceRef = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; if prev.is_null() { jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?; } else { - jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?; + jvm.put_field(&mut prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", next) + .await?; } - let count: i32 = jvm.get_field(&this, "count", "I").await?; - jvm.put_field(&mut this, "count", "I", count - 1).await?; + let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?; + jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count - 1).await?; - return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await; + return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await; } } prev = entry; - entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } Ok(None.into()) @@ -338,33 +365,41 @@ impl Hashtable { } let key_hash = Self::key_hash(jvm, &key).await?; - let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let mut table = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await? as i32; let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize; let mut entry: ClassInstanceRef = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap(); while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let equals: bool = jvm .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; if equals { - let old_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?; + let old_value: ClassInstanceRef = + jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;", value) + .await?; return Ok(old_value); } } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?; + let threshold: i32 = jvm.get_field(&this, "java/util/Hashtable", "threshold", "I").await?; if count >= threshold { Self::rehash_table(jvm, &mut this).await?; - table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + table = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let new_table_len = jvm.array_length(&table).await? as i32; let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize; @@ -389,7 +424,7 @@ impl Hashtable { jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?; } - jvm.put_field(&mut this, "count", "I", count + 1).await?; + jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count + 1).await?; Ok(None.into()) } @@ -446,13 +481,15 @@ impl Hashtable { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Hashtable::clear({this:?})"); - let mut table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let mut table: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; if table_len > 0 { let nulls: Vec> = (0..table_len).map(|_| None.into()).collect(); jvm.store_array(&mut table, 0, nulls).await?; } - jvm.put_field(&mut this, "count", "I", 0).await?; + jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?; Ok(()) } @@ -499,15 +536,17 @@ impl Hashtable { key: &ClassInstanceRef, ) -> Result> { let key_hash = Self::key_hash(jvm, key).await?; - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await? as i32; let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize; let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; if entry_hash == key_hash { - let entry_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let entry_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let equals: bool = jvm .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; @@ -516,7 +555,9 @@ impl Hashtable { } } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } Ok(None.into()) @@ -528,7 +569,9 @@ impl Hashtable { } async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let old_table = jvm + .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let old_capacity = jvm.array_length(&old_table).await?; let new_capacity = old_capacity * 2 + 1; @@ -537,21 +580,31 @@ impl Hashtable { for i in 0..old_capacity { let mut entry: ClassInstanceRef = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap(); while !entry.is_null() { - let next: ClassInstanceRef = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; - let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?; + let next: ClassInstanceRef = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; + let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?; let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize; let existing: ClassInstanceRef = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap(); - jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?; + jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", existing) + .await?; jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?; entry = next; } } - jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?; - jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32) + jvm.put_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", new_table) .await?; + jvm.put_field( + this, + "java/util/Hashtable", + "threshold", + "I", + (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32, + ) + .await?; Ok(()) } @@ -566,20 +619,22 @@ impl Hashtable { return Ok(false); } - let count: i32 = jvm.get_field(&this, "count", "I").await?; + let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?; let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?; if count != other_size { return Ok(false); } let comparison: Result = async { - let table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { - let key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; - let value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; let other_value: ClassInstanceRef = jvm .invoke_virtual( &other, @@ -604,7 +659,9 @@ impl Hashtable { return Ok(false); } - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } } @@ -625,29 +682,33 @@ impl Hashtable { async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable::hashCode({this:?})"); - let count: i32 = jvm.get_field(&this, "count", "I").await?; - let load_factor: f32 = jvm.get_field(&this, "loadFactor", "F").await?; + let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?; + let load_factor: f32 = jvm.get_field(&this, "java/util/Hashtable", "loadFactor", "F").await?; if count == 0 || load_factor < 0.0 { return Ok(0); } - jvm.put_field(&mut this, "loadFactor", "F", -load_factor).await?; + jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", -load_factor).await?; let result: Result = async { - let table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; let mut hash = 0i32; for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?); - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } } Ok(hash) } .await; - jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?; + jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", load_factor).await?; result } @@ -664,7 +725,7 @@ impl Hashtable { } let entry: ClassInstanceRef = ClassInstanceRef::new(entry.instance); - let key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; if key.instance.as_ref().unwrap().equals(&**this)? { result.push_str("(this Map)"); } else { @@ -675,7 +736,7 @@ impl Hashtable { } result.push('='); - let value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; if value.instance.as_ref().unwrap().equals(&**this)? { result.push_str("(this Map)"); } else { @@ -720,22 +781,26 @@ impl Hashtable { } async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef, kind: SnapshotKind) -> Result>> { - let table: ClassInstanceRef> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; - let count: i32 = jvm.get_field(this, "count", "I").await?; + let count: i32 = jvm.get_field(this, "java/util/Hashtable", "count", "I").await?; let mut elements: Vec> = Vec::with_capacity(count as usize); for bucket_index in 0..table_len { let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?; while !entry.is_null() { let element = match kind { - SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?, - SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?, + SnapshotKind::Keys => jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?, + SnapshotKind::Values => jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?, SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance), }; elements.push(element); - entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;") + .await?; } } diff --git a/rustjava-runtime/src/classes/java/util/hashtable_entry.rs b/rustjava-runtime/src/classes/java/util/hashtable_entry.rs index f54a6c60..8964a2b6 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable_entry.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable_entry.rs @@ -56,10 +56,13 @@ impl HashtableEntry { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "hash", "I", hash).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "next", "Ljava/util/Hashtable$Entry;", next).await?; + jvm.put_field(&mut this, "java/util/Hashtable$Entry", "hash", "I", hash).await?; + jvm.put_field(&mut this, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;", key) + .await?; + jvm.put_field(&mut this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;", value) + .await?; + jvm.put_field(&mut this, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", next) + .await?; Ok(()) } @@ -67,13 +70,13 @@ impl HashtableEntry { async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$Entry::getKey({this:?})"); - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$Entry::getValue({this:?})"); - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -88,8 +91,9 @@ impl HashtableEntry { return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await); } - let old_value = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old_value = jvm.get_field(&this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;", value) + .await?; Ok(old_value) } @@ -99,7 +103,7 @@ impl HashtableEntry { return Ok(false); } - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; let other_key: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await?; @@ -113,7 +117,7 @@ impl HashtableEntry { return Ok(false); } - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; let other_value: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; @@ -126,8 +130,8 @@ impl HashtableEntry { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; let key_hash = if key.is_null() { 0 } else { diff --git a/rustjava-runtime/src/classes/java/util/hashtable_entry_set.rs b/rustjava-runtime/src/classes/java/util/hashtable_entry_set.rs index c03888e6..b8e82857 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable_entry_set.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable_entry_set.rs @@ -35,7 +35,8 @@ impl HashtableEntrySet { tracing::debug!("java.util.Hashtable$EntrySet::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/Hashtable;", map).await?; + jvm.put_field(&mut this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;", map) + .await?; Ok(()) } @@ -43,7 +44,9 @@ impl HashtableEntrySet { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$EntrySet::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "size", "()I", ()).await } @@ -51,7 +54,9 @@ impl HashtableEntrySet { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$EntrySet::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "isEmpty", "()Z", ()).await } @@ -70,7 +75,9 @@ impl HashtableEntrySet { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; let entry = Hashtable::find_entry(jvm, &map, &candidate_key).await?; if entry.is_null() { return Ok(false); @@ -79,7 +86,7 @@ impl HashtableEntrySet { let candidate_value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; Self::object_equals(jvm, &entry_value, &candidate_value).await } @@ -97,7 +104,9 @@ impl HashtableEntrySet { if candidate_key.is_null() { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; let entry = Hashtable::find_entry(jvm, &map, &candidate_key).await?; if entry.is_null() { return Ok(false); @@ -105,7 +114,7 @@ impl HashtableEntrySet { let candidate_value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?; if !Self::object_equals(jvm, &entry_value, &candidate_value).await? { return Ok(false); } @@ -126,7 +135,9 @@ impl HashtableEntrySet { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Hashtable$EntrySet::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "clear", "()V", ()).await } @@ -134,7 +145,9 @@ impl HashtableEntrySet { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$EntrySet::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/Hashtable$EntrySet", "map", "Ljava/util/Hashtable;") + .await?; let snapshot = Hashtable::entries_snapshot(jvm, &map).await?; let iterator = jvm .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,)) diff --git a/rustjava-runtime/src/classes/java/util/hashtable_enumerator.rs b/rustjava-runtime/src/classes/java/util/hashtable_enumerator.rs index fb6f8426..bdacb979 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable_enumerator.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable_enumerator.rs @@ -36,8 +36,9 @@ impl HashtableEnumerator { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "elements", "[Ljava/lang/Object;", elements).await?; - jvm.put_field(&mut this, "index", "I", 0).await?; + jvm.put_field(&mut this, "java/util/Hashtable$Enumerator", "elements", "[Ljava/lang/Object;", elements) + .await?; + jvm.put_field(&mut this, "java/util/Hashtable$Enumerator", "index", "I", 0).await?; Ok(()) } @@ -53,8 +54,10 @@ impl HashtableEnumerator { async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$Enumerator::hasNext({this:?})"); - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable$Enumerator", "elements", "[Ljava/lang/Object;") + .await?; + let index: i32 = jvm.get_field(&this, "java/util/Hashtable$Enumerator", "index", "I").await?; if index < 0 { return Ok(false); } @@ -65,8 +68,10 @@ impl HashtableEnumerator { async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$Enumerator::next({this:?})"); - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm + .get_field(&this, "java/util/Hashtable$Enumerator", "elements", "[Ljava/lang/Object;") + .await?; + let index: i32 = jvm.get_field(&this, "java/util/Hashtable$Enumerator", "index", "I").await?; if index < 0 || index as usize >= jvm.array_length(&elements).await? { return Err(jvm.exception("java/util/NoSuchElementException", "Hashtable iterator exhausted").await); } @@ -75,7 +80,8 @@ impl HashtableEnumerator { let Some(element) = values.pop() else { return Err(jvm.exception("java/util/NoSuchElementException", "Hashtable iterator exhausted").await); }; - jvm.put_field(&mut this, "index", "I", index + 1).await?; + jvm.put_field(&mut this, "java/util/Hashtable$Enumerator", "index", "I", index + 1) + .await?; Ok(element) } diff --git a/rustjava-runtime/src/classes/java/util/hashtable_key_set.rs b/rustjava-runtime/src/classes/java/util/hashtable_key_set.rs index 8776260b..8037ce2c 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable_key_set.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable_key_set.rs @@ -35,7 +35,8 @@ impl HashtableKeySet { tracing::debug!("java.util.Hashtable$KeySet::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/Hashtable;", map).await?; + jvm.put_field(&mut this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;", map) + .await?; Ok(()) } @@ -43,7 +44,7 @@ impl HashtableKeySet { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$KeySet::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "size", "()I", ()).await } @@ -51,7 +52,7 @@ impl HashtableKeySet { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$KeySet::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "isEmpty", "()Z", ()).await } @@ -59,7 +60,7 @@ impl HashtableKeySet { async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$KeySet::contains({this:?}, {key:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "containsKey", "(Ljava/lang/Object;)Z", (key,)) .await @@ -68,7 +69,7 @@ impl HashtableKeySet { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$KeySet::remove({this:?}, {key:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; let contains: bool = jvm .invoke_virtual(&map, "java/util/Hashtable", "containsKey", "(Ljava/lang/Object;)Z", (key.clone(),)) .await?; @@ -86,7 +87,7 @@ impl HashtableKeySet { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Hashtable$KeySet::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "clear", "()V", ()).await } @@ -94,7 +95,7 @@ impl HashtableKeySet { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$KeySet::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$KeySet", "map", "Ljava/util/Hashtable;").await?; let snapshot = Hashtable::keys_snapshot(jvm, &map).await?; let iterator = jvm .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,)) diff --git a/rustjava-runtime/src/classes/java/util/hashtable_values.rs b/rustjava-runtime/src/classes/java/util/hashtable_values.rs index 5583e64f..760fddab 100644 --- a/rustjava-runtime/src/classes/java/util/hashtable_values.rs +++ b/rustjava-runtime/src/classes/java/util/hashtable_values.rs @@ -35,7 +35,8 @@ impl HashtableValues { tracing::debug!("java.util.Hashtable$Values::({this:?}, {map:?})"); let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/Hashtable;", map).await?; + jvm.put_field(&mut this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;", map) + .await?; Ok(()) } @@ -43,7 +44,7 @@ impl HashtableValues { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$Values::size({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "size", "()I", ()).await } @@ -51,7 +52,7 @@ impl HashtableValues { async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$Values::isEmpty({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "isEmpty", "()Z", ()).await } @@ -59,7 +60,7 @@ impl HashtableValues { async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { tracing::debug!("java.util.Hashtable$Values::contains({this:?}, {value:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,)) .await @@ -72,7 +73,7 @@ impl HashtableValues { return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; let entries = Hashtable::entries_snapshot(jvm, &map).await?; let count = jvm.array_length(&entries).await?; for entry in jvm.load_array::>(&entries, 0, count).await? { @@ -99,7 +100,7 @@ impl HashtableValues { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Hashtable$Values::clear({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; jvm.invoke_virtual(&map, "java/util/Hashtable", "clear", "()V", ()).await } @@ -107,7 +108,7 @@ impl HashtableValues { async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Hashtable$Values::iterator({this:?})"); - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/Hashtable;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/Hashtable$Values", "map", "Ljava/util/Hashtable;").await?; let snapshot = Hashtable::values_snapshot(jvm, &map).await?; let iterator = jvm .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,)) diff --git a/rustjava-runtime/src/classes/java/util/illegal_format_code_point_exception.rs b/rustjava-runtime/src/classes/java/util/illegal_format_code_point_exception.rs index 4428e849..334b1aed 100644 --- a/rustjava-runtime/src/classes/java/util/illegal_format_code_point_exception.rs +++ b/rustjava-runtime/src/classes/java/util/illegal_format_code_point_exception.rs @@ -27,15 +27,18 @@ impl IllegalFormatCodePointException { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, code_point: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "codePoint", "I", code_point).await + jvm.put_field(&mut this, "java/util/IllegalFormatCodePointException", "codePoint", "I", code_point) + .await } async fn get_code_point(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "codePoint", "I").await + jvm.get_field(&this, "java/util/IllegalFormatCodePointException", "codePoint", "I").await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let code_point: i32 = jvm.get_field(&this, "codePoint", "I").await?; + let code_point: i32 = jvm + .get_field(&this, "java/util/IllegalFormatCodePointException", "codePoint", "I") + .await?; Ok(JavaLangString::from_rust_string(jvm, &format!("Code point = 0x{code_point:x}")) .await? .into()) diff --git a/rustjava-runtime/src/classes/java/util/illegal_format_conversion_exception.rs b/rustjava-runtime/src/classes/java/util/illegal_format_conversion_exception.rs index 95612548..5ca0ae16 100644 --- a/rustjava-runtime/src/classes/java/util/illegal_format_conversion_exception.rs +++ b/rustjava-runtime/src/classes/java/util/illegal_format_conversion_exception.rs @@ -48,21 +48,35 @@ impl IllegalFormatConversionException { return Err(jvm.exception("java/lang/NullPointerException", "argumentClass is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "conversion", "C", conversion).await?; - jvm.put_field(&mut this, "argumentClass", "Ljava/lang/Class;", argument_class).await + jvm.put_field(&mut this, "java/util/IllegalFormatConversionException", "conversion", "C", conversion) + .await?; + jvm.put_field( + &mut this, + "java/util/IllegalFormatConversionException", + "argumentClass", + "Ljava/lang/Class;", + argument_class, + ) + .await } async fn get_conversion(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "conversion", "C").await + jvm.get_field(&this, "java/util/IllegalFormatConversionException", "conversion", "C") + .await } async fn get_argument_class(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "argumentClass", "Ljava/lang/Class;").await + jvm.get_field(&this, "java/util/IllegalFormatConversionException", "argumentClass", "Ljava/lang/Class;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let conversion: JavaChar = jvm.get_field(&this, "conversion", "C").await?; - let argument_class: ClassInstanceRef = jvm.get_field(&this, "argumentClass", "Ljava/lang/Class;").await?; + let conversion: JavaChar = jvm + .get_field(&this, "java/util/IllegalFormatConversionException", "conversion", "C") + .await?; + let argument_class: ClassInstanceRef = jvm + .get_field(&this, "java/util/IllegalFormatConversionException", "argumentClass", "Ljava/lang/Class;") + .await?; let class_name: ClassInstanceRef = jvm .invoke_virtual(&argument_class, "java/lang/Class", "getName", "()Ljava/lang/String;", ()) .await?; diff --git a/rustjava-runtime/src/classes/java/util/illegal_format_flags_exception.rs b/rustjava-runtime/src/classes/java/util/illegal_format_flags_exception.rs index 74e038af..847f659e 100644 --- a/rustjava-runtime/src/classes/java/util/illegal_format_flags_exception.rs +++ b/rustjava-runtime/src/classes/java/util/illegal_format_flags_exception.rs @@ -30,15 +30,19 @@ impl IllegalFormatFlagsException { return Err(jvm.exception("java/lang/NullPointerException", "flags is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "flags", "Ljava/lang/String;", flags).await + jvm.put_field(&mut this, "java/util/IllegalFormatFlagsException", "flags", "Ljava/lang/String;", flags) + .await } async fn get_flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "flags", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/IllegalFormatFlagsException", "flags", "Ljava/lang/String;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let flags: ClassInstanceRef = jvm.get_field(&this, "flags", "Ljava/lang/String;").await?; + let flags: ClassInstanceRef = jvm + .get_field(&this, "java/util/IllegalFormatFlagsException", "flags", "Ljava/lang/String;") + .await?; JavaLangString::from_rust_string(jvm, &alloc::format!("Flags = '{}'", JavaLangString::to_rust_string(jvm, &flags).await?)) .await .map(Into::into) diff --git a/rustjava-runtime/src/classes/java/util/illegal_format_precision_exception.rs b/rustjava-runtime/src/classes/java/util/illegal_format_precision_exception.rs index bf2eb450..7b7d5f13 100644 --- a/rustjava-runtime/src/classes/java/util/illegal_format_precision_exception.rs +++ b/rustjava-runtime/src/classes/java/util/illegal_format_precision_exception.rs @@ -27,15 +27,18 @@ impl IllegalFormatPrecisionException { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, precision: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "precision", "I", precision).await + jvm.put_field(&mut this, "java/util/IllegalFormatPrecisionException", "precision", "I", precision) + .await } async fn get_precision(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "precision", "I").await + jvm.get_field(&this, "java/util/IllegalFormatPrecisionException", "precision", "I").await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let precision: i32 = jvm.get_field(&this, "precision", "I").await?; + let precision: i32 = jvm + .get_field(&this, "java/util/IllegalFormatPrecisionException", "precision", "I") + .await?; Ok(JavaLangString::from_rust_string(jvm, &precision.to_string()).await?.into()) } } diff --git a/rustjava-runtime/src/classes/java/util/illegal_format_width_exception.rs b/rustjava-runtime/src/classes/java/util/illegal_format_width_exception.rs index c7c3e575..e4fd41a8 100644 --- a/rustjava-runtime/src/classes/java/util/illegal_format_width_exception.rs +++ b/rustjava-runtime/src/classes/java/util/illegal_format_width_exception.rs @@ -27,15 +27,16 @@ impl IllegalFormatWidthException { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, width: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "width", "I", width).await + jvm.put_field(&mut this, "java/util/IllegalFormatWidthException", "width", "I", width) + .await } async fn get_width(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "width", "I").await + jvm.get_field(&this, "java/util/IllegalFormatWidthException", "width", "I").await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let width: i32 = jvm.get_field(&this, "width", "I").await?; + let width: i32 = jvm.get_field(&this, "java/util/IllegalFormatWidthException", "width", "I").await?; Ok(JavaLangString::from_rust_string(jvm, &width.to_string()).await?.into()) } } diff --git a/rustjava-runtime/src/classes/java/util/jar/attributes.rs b/rustjava-runtime/src/classes/java/util/jar/attributes.rs index 8408cd01..dff2ebc7 100644 --- a/rustjava-runtime/src/classes/java/util/jar/attributes.rs +++ b/rustjava-runtime/src/classes/java/util/jar/attributes.rs @@ -41,7 +41,8 @@ impl Attributes { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let map = jvm.new_class("java/util/HashMap", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/Map;", map).await?; + jvm.put_field(&mut this, "java/util/jar/Attributes", "map", "Ljava/util/Map;", map) + .await?; Ok(()) } @@ -56,7 +57,7 @@ impl Attributes { tracing::debug!("java.util.jar.Attributes::putValue({this:?}, {name:?}, {value:?})"); // TODO we should store key in Attributes.Name type - let map = jvm.get_field(&this, "map", "Ljava/util/Map;").await?; + let map = jvm.get_field(&this, "java/util/jar/Attributes", "map", "Ljava/util/Map;").await?; let old = jvm .invoke_virtual( &map, @@ -78,7 +79,7 @@ impl Attributes { ) -> Result> { tracing::debug!("java.util.jar.Attributes::getValue({this:?}, {name:?})"); - let map = jvm.get_field(&this, "map", "Ljava/util/Map;").await?; + let map = jvm.get_field(&this, "java/util/jar/Attributes", "map", "Ljava/util/Map;").await?; let value = jvm .invoke_virtual( &map, diff --git a/rustjava-runtime/src/classes/java/util/jar/jar_file_entries.rs b/rustjava-runtime/src/classes/java/util/jar/jar_file_entries.rs index b872d65a..c8425c7d 100644 --- a/rustjava-runtime/src/classes/java/util/jar/jar_file_entries.rs +++ b/rustjava-runtime/src/classes/java/util/jar/jar_file_entries.rs @@ -40,7 +40,14 @@ impl JarFileEntries { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "entries", "Ljava/util/zip/ZipFile$Entries;", entries).await?; + jvm.put_field( + &mut this, + "java/util/jar/JarFile$Entries", + "entries", + "Ljava/util/zip/ZipFile$Entries;", + entries, + ) + .await?; Ok(()) } @@ -48,7 +55,9 @@ impl JarFileEntries { async fn has_more_elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.jar.JarFile$Entries::hasMoreElements({this:?})"); - let entries = jvm.get_field(&this, "entries", "Ljava/util/zip/ZipFile$Entries;").await?; + let entries = jvm + .get_field(&this, "java/util/jar/JarFile$Entries", "entries", "Ljava/util/zip/ZipFile$Entries;") + .await?; jvm.invoke_virtual(&entries, "java/util/zip/ZipFile$Entries", "hasMoreElements", "()Z", ()) .await @@ -57,7 +66,9 @@ impl JarFileEntries { async fn next_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.jar.JarFile$Entries::nextElement({this:?})"); - let entries = jvm.get_field(&this, "entries", "Ljava/util/zip/ZipFile$Entries;").await?; + let entries = jvm + .get_field(&this, "java/util/jar/JarFile$Entries", "entries", "Ljava/util/zip/ZipFile$Entries;") + .await?; let element: ClassInstanceRef = jvm .invoke_virtual(&entries, "java/util/zip/ZipFile$Entries", "nextElement", "()Ljava/lang/Object;", ()) diff --git a/rustjava-runtime/src/classes/java/util/jar/manifest.rs b/rustjava-runtime/src/classes/java/util/jar/manifest.rs index e6034164..825c9be4 100644 --- a/rustjava-runtime/src/classes/java/util/jar/manifest.rs +++ b/rustjava-runtime/src/classes/java/util/jar/manifest.rs @@ -85,7 +85,14 @@ impl Manifest { .await?; } - jvm.put_field(&mut this, "attrs", "Ljava/util/jar/Attributes;", main_attributes).await?; + jvm.put_field( + &mut this, + "java/util/jar/Manifest", + "attrs", + "Ljava/util/jar/Attributes;", + main_attributes, + ) + .await?; Ok(()) } @@ -93,6 +100,7 @@ impl Manifest { async fn get_main_attributes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.jar.Manifest::getMainAttributes({this:?})"); - jvm.get_field(&this, "attrs", "Ljava/util/jar/Attributes;").await + jvm.get_field(&this, "java/util/jar/Manifest", "attrs", "Ljava/util/jar/Attributes;") + .await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_hash_map.rs b/rustjava-runtime/src/classes/java/util/linked_hash_map.rs index 6067a6a7..4aa770ec 100644 --- a/rustjava-runtime/src/classes/java/util/linked_hash_map.rs +++ b/rustjava-runtime/src/classes/java/util/linked_hash_map.rs @@ -123,7 +123,8 @@ impl LinkedHashMap { let _: () = jvm .invoke_special(&this, "java/util/HashMap", "", "(IF)V", (capacity, load_factor)) .await?; - jvm.put_field(&mut this, "accessOrder", "Z", access_order).await + jvm.put_field(&mut this, "java/util/LinkedHashMap", "accessOrder", "Z", access_order) + .await } async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { @@ -175,18 +176,38 @@ impl LinkedHashMap { .await? .into(); let header_ref = header.clone(); - jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", header_ref) - .await?; + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + header_ref, + ) + .await?; let header_ref = header.clone(); - jvm.put_field(&mut header, "after", "Ljava/util/LinkedHashMap$Entry;", header_ref).await?; - jvm.put_field(&mut this, "header", "Ljava/util/LinkedHashMap$Entry;", header).await + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + header_ref, + ) + .await?; + jvm.put_field(&mut this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;", header) + .await } async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let mut entry: ClassInstanceRef = jvm.get_field(&header, "after", "Ljava/util/LinkedHashMap$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let mut entry: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") + .await?; while entry.identity() != header.identity() { - let entry_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let entry_value: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedHashMap$Entry", "value", "Ljava/lang/Object;") + .await?; let equal = if value.is_null() { entry_value.is_null() } else if entry_value.is_null() { @@ -198,7 +219,9 @@ impl LinkedHashMap { if equal { return Ok(true); } - entry = jvm.get_field(&entry, "after", "Ljava/util/LinkedHashMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") + .await?; } Ok(false) @@ -214,17 +237,32 @@ impl LinkedHashMap { .invoke_virtual(&entry, "java/util/HashMap$Entry", "onAccess", "(Ljava/util/HashMap;)V", (map,)) .await?; - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/HashMap", "clear", "()V", ()).await?; - let mut header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let header_ref = header.clone(); - jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", header_ref) + let mut header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") .await?; let header_ref = header.clone(); - jvm.put_field(&mut header, "after", "Ljava/util/LinkedHashMap$Entry;", header_ref).await + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + header_ref, + ) + .await?; + let header_ref = header.clone(); + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + header_ref, + ) + .await } async fn store_new_entry( @@ -236,7 +274,9 @@ impl LinkedHashMap { value: ClassInstanceRef, bucket_index: i32, ) -> Result<()> { - let mut table: ClassInstanceRef> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?; + let mut table: ClassInstanceRef> = jvm + .get_field(&this, "java/util/LinkedHashMap", "table", "[Ljava/util/HashMap$Entry;") + .await?; let existing = jvm .load_array::>(&table, bucket_index as usize, 1) .await? @@ -252,18 +292,47 @@ impl LinkedHashMap { let bucket_entry: ClassInstanceRef = ClassInstanceRef::new(entry.instance.clone()); jvm.store_array(&mut table, bucket_index as usize, core::iter::once(bucket_entry)).await?; - let mut header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let mut tail: ClassInstanceRef = jvm.get_field(&header, "before", "Ljava/util/LinkedHashMap$Entry;").await?; - jvm.put_field(&mut entry, "before", "Ljava/util/LinkedHashMap$Entry;", tail.clone()) - .await?; - jvm.put_field(&mut entry, "after", "Ljava/util/LinkedHashMap$Entry;", header.clone()) + let mut header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut tail, "after", "Ljava/util/LinkedHashMap$Entry;", entry.clone()) + let mut tail: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedHashMap$Entry", "before", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", entry).await?; + jvm.put_field( + &mut entry, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + tail.clone(), + ) + .await?; + jvm.put_field( + &mut entry, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + header.clone(), + ) + .await?; + jvm.put_field( + &mut tail, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + entry.clone(), + ) + .await?; + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + entry, + ) + .await?; - let size: i32 = jvm.get_field(&this, "size", "I").await?; - jvm.put_field(&mut this, "size", "I", size + 1).await + let size: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "size", "I").await?; + jvm.put_field(&mut this, "java/util/LinkedHashMap", "size", "I", size + 1).await } async fn insert_new_entry( @@ -275,9 +344,10 @@ impl LinkedHashMap { value: ClassInstanceRef, bucket_index: i32, ) -> Result<()> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; - let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?; - jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?; + let size: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "size", "I").await?; + let mod_count: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "modCount", "I").await?; + jvm.put_field(&mut this, "java/util/LinkedHashMap", "modCount", "I", mod_count.wrapping_add(1)) + .await?; let _: () = jvm .invoke_virtual( &this, @@ -288,8 +358,12 @@ impl LinkedHashMap { ) .await?; - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let eldest: ClassInstanceRef = jvm.get_field(&header, "after", "Ljava/util/LinkedHashMap$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let eldest: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") + .await?; let eldest_entry: ClassInstanceRef = ClassInstanceRef::new(eldest.instance.clone()); if jvm .invoke_virtual::<_, bool>( @@ -301,7 +375,9 @@ impl LinkedHashMap { ) .await? { - let key: ClassInstanceRef = jvm.get_field(&eldest, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm + .get_field(&eldest, "java/util/LinkedHashMap$Entry", "key", "Ljava/lang/Object;") + .await?; let _: ClassInstanceRef = jvm .invoke_virtual( &this, @@ -312,7 +388,7 @@ impl LinkedHashMap { ) .await?; } else { - let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?; + let threshold: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "threshold", "I").await?; if size >= threshold { let mut map: ClassInstanceRef = ClassInstanceRef::new(this.instance.clone()); HashMap::rehash(jvm, &mut map).await?; diff --git a/rustjava-runtime/src/classes/java/util/linked_hash_map_entry.rs b/rustjava-runtime/src/classes/java/util/linked_hash_map_entry.rs index 822af990..902025bc 100644 --- a/rustjava-runtime/src/classes/java/util/linked_hash_map_entry.rs +++ b/rustjava-runtime/src/classes/java/util/linked_hash_map_entry.rs @@ -56,38 +56,103 @@ impl LinkedHashMapEntry { async fn on_access(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { let mut map: ClassInstanceRef = ClassInstanceRef::new(map.instance); - if !jvm.get_field::(&map, "accessOrder", "Z").await? { + if !jvm.get_field::(&map, "java/util/LinkedHashMap", "accessOrder", "Z").await? { return Ok(()); } - let mut header: ClassInstanceRef = jvm.get_field(&map, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let mut tail: ClassInstanceRef = jvm.get_field(&header, "before", "Ljava/util/LinkedHashMap$Entry;").await?; + let mut header: ClassInstanceRef = jvm + .get_field(&map, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let mut tail: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedHashMap$Entry", "before", "Ljava/util/LinkedHashMap$Entry;") + .await?; if this.identity() == tail.identity() { return Ok(()); } - let mut before: ClassInstanceRef = jvm.get_field(&this, "before", "Ljava/util/LinkedHashMap$Entry;").await?; - let mut after: ClassInstanceRef = jvm.get_field(&this, "after", "Ljava/util/LinkedHashMap$Entry;").await?; - jvm.put_field(&mut before, "after", "Ljava/util/LinkedHashMap$Entry;", after.clone()) - .await?; - jvm.put_field(&mut after, "before", "Ljava/util/LinkedHashMap$Entry;", before).await?; - - jvm.put_field(&mut this, "before", "Ljava/util/LinkedHashMap$Entry;", tail.clone()) + let mut before: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$Entry", "before", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut this, "after", "Ljava/util/LinkedHashMap$Entry;", header.clone()) + let mut after: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut tail, "after", "Ljava/util/LinkedHashMap$Entry;", this.clone()).await?; - jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", this).await?; + jvm.put_field( + &mut before, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + after.clone(), + ) + .await?; + jvm.put_field( + &mut after, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + before, + ) + .await?; - let mod_count: i32 = jvm.get_field(&map, "modCount", "I").await?; - jvm.put_field(&mut map, "modCount", "I", mod_count.wrapping_add(1)).await + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + tail.clone(), + ) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + header.clone(), + ) + .await?; + jvm.put_field( + &mut tail, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + this.clone(), + ) + .await?; + jvm.put_field( + &mut header, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + this, + ) + .await?; + + let mod_count: i32 = jvm.get_field(&map, "java/util/LinkedHashMap", "modCount", "I").await?; + jvm.put_field(&mut map, "java/util/LinkedHashMap", "modCount", "I", mod_count.wrapping_add(1)) + .await } async fn on_removal(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: ClassInstanceRef) -> Result<()> { - let mut before: ClassInstanceRef = jvm.get_field(&this, "before", "Ljava/util/LinkedHashMap$Entry;").await?; - let mut after: ClassInstanceRef = jvm.get_field(&this, "after", "Ljava/util/LinkedHashMap$Entry;").await?; - jvm.put_field(&mut before, "after", "Ljava/util/LinkedHashMap$Entry;", after.clone()) + let mut before: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$Entry", "before", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let mut after: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut after, "before", "Ljava/util/LinkedHashMap$Entry;", before).await + jvm.put_field( + &mut before, + "java/util/LinkedHashMap$Entry", + "after", + "Ljava/util/LinkedHashMap$Entry;", + after.clone(), + ) + .await?; + jvm.put_field( + &mut after, + "java/util/LinkedHashMap$Entry", + "before", + "Ljava/util/LinkedHashMap$Entry;", + before, + ) + .await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_hash_map_key_iterator.rs b/rustjava-runtime/src/classes/java/util/linked_hash_map_key_iterator.rs index 71549b3b..bb9f75e1 100644 --- a/rustjava-runtime/src/classes/java/util/linked_hash_map_key_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/linked_hash_map_key_iterator.rs @@ -48,6 +48,6 @@ impl LinkedHashMapKeyIterator { ) .await?; - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/LinkedHashMap$Entry", "key", "Ljava/lang/Object;").await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_hash_map_linked_hash_iterator.rs b/rustjava-runtime/src/classes/java/util/linked_hash_map_linked_hash_iterator.rs index 40ee5937..dfde77e4 100644 --- a/rustjava-runtime/src/classes/java/util/linked_hash_map_linked_hash_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/linked_hash_map_linked_hash_iterator.rs @@ -40,65 +40,148 @@ impl LinkedHashMapLinkedHashIterator { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - let header: ClassInstanceRef = jvm.get_field(&map, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&header, "after", "Ljava/util/LinkedHashMap$Entry;").await?; - let mod_count: i32 = jvm.get_field(&map, "modCount", "I").await?; - let last_returned: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "map", "Ljava/util/LinkedHashMap;", map).await?; - jvm.put_field(&mut this, "nextEntry", "Ljava/util/LinkedHashMap$Entry;", next).await?; - jvm.put_field(&mut this, "lastReturned", "Ljava/util/LinkedHashMap$Entry;", last_returned) + let header: ClassInstanceRef = jvm + .get_field(&map, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut this, "expectedModCount", "I", mod_count).await + let mod_count: i32 = jvm.get_field(&map, "java/util/LinkedHashMap", "modCount", "I").await?; + let last_returned: ClassInstanceRef = None.into(); + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "map", + "Ljava/util/LinkedHashMap;", + map, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "nextEntry", + "Ljava/util/LinkedHashMap$Entry;", + next, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "lastReturned", + "Ljava/util/LinkedHashMap$Entry;", + last_returned, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "expectedModCount", + "I", + mod_count, + ) + .await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/LinkedHashMap;").await?; - let header: ClassInstanceRef = jvm.get_field(&map, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&this, "nextEntry", "Ljava/util/LinkedHashMap$Entry;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$LinkedHashIterator", "map", "Ljava/util/LinkedHashMap;") + .await?; + let header: ClassInstanceRef = jvm + .get_field(&map, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/LinkedHashMap$LinkedHashIterator", + "nextEntry", + "Ljava/util/LinkedHashMap$Entry;", + ) + .await?; Ok(next.identity() != header.identity()) } async fn next_entry(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/LinkedHashMap;").await?; - let expected_mod_count: i32 = jvm.get_field(&this, "expectedModCount", "I").await?; - let mod_count: i32 = jvm.get_field(&map, "modCount", "I").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$LinkedHashIterator", "map", "Ljava/util/LinkedHashMap;") + .await?; + let expected_mod_count: i32 = jvm + .get_field(&this, "java/util/LinkedHashMap$LinkedHashIterator", "expectedModCount", "I") + .await?; + let mod_count: i32 = jvm.get_field(&map, "java/util/LinkedHashMap", "modCount", "I").await?; if expected_mod_count != mod_count { return Err(jvm .exception("java/util/ConcurrentModificationException", "LinkedHashMap modified during iteration") .await); } - let header: ClassInstanceRef = jvm.get_field(&map, "header", "Ljava/util/LinkedHashMap$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&this, "nextEntry", "Ljava/util/LinkedHashMap$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&map, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/LinkedHashMap$LinkedHashIterator", + "nextEntry", + "Ljava/util/LinkedHashMap$Entry;", + ) + .await?; if next.identity() == header.identity() { return Err(jvm .exception("java/util/NoSuchElementException", "LinkedHashMap iterator exhausted") .await); } - let after: ClassInstanceRef = jvm.get_field(&next, "after", "Ljava/util/LinkedHashMap$Entry;").await?; - jvm.put_field(&mut this, "lastReturned", "Ljava/util/LinkedHashMap$Entry;", next.clone()) + let after: ClassInstanceRef = jvm + .get_field(&next, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;") .await?; - jvm.put_field(&mut this, "nextEntry", "Ljava/util/LinkedHashMap$Entry;", after).await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "lastReturned", + "Ljava/util/LinkedHashMap$Entry;", + next.clone(), + ) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "nextEntry", + "Ljava/util/LinkedHashMap$Entry;", + after, + ) + .await?; Ok(next) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: ClassInstanceRef = jvm.get_field(&this, "lastReturned", "Ljava/util/LinkedHashMap$Entry;").await?; + let last_returned: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/LinkedHashMap$LinkedHashIterator", + "lastReturned", + "Ljava/util/LinkedHashMap$Entry;", + ) + .await?; if last_returned.is_null() { return Err(jvm.exception("java/lang/IllegalStateException", "Iterator.remove").await); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/LinkedHashMap;").await?; - let expected_mod_count: i32 = jvm.get_field(&this, "expectedModCount", "I").await?; - let mod_count: i32 = jvm.get_field(&map, "modCount", "I").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedHashMap$LinkedHashIterator", "map", "Ljava/util/LinkedHashMap;") + .await?; + let expected_mod_count: i32 = jvm + .get_field(&this, "java/util/LinkedHashMap$LinkedHashIterator", "expectedModCount", "I") + .await?; + let mod_count: i32 = jvm.get_field(&map, "java/util/LinkedHashMap", "modCount", "I").await?; if expected_mod_count != mod_count { return Err(jvm .exception("java/util/ConcurrentModificationException", "LinkedHashMap modified during iteration") .await); } - let key: ClassInstanceRef = jvm.get_field(&last_returned, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm + .get_field(&last_returned, "java/util/LinkedHashMap$Entry", "key", "Ljava/lang/Object;") + .await?; let _: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -109,9 +192,22 @@ impl LinkedHashMapLinkedHashIterator { ) .await?; let last_returned: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "lastReturned", "Ljava/util/LinkedHashMap$Entry;", last_returned) - .await?; - let mod_count: i32 = jvm.get_field(&map, "modCount", "I").await?; - jvm.put_field(&mut this, "expectedModCount", "I", mod_count).await + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "lastReturned", + "Ljava/util/LinkedHashMap$Entry;", + last_returned, + ) + .await?; + let mod_count: i32 = jvm.get_field(&map, "java/util/LinkedHashMap", "modCount", "I").await?; + jvm.put_field( + &mut this, + "java/util/LinkedHashMap$LinkedHashIterator", + "expectedModCount", + "I", + mod_count, + ) + .await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_hash_map_value_iterator.rs b/rustjava-runtime/src/classes/java/util/linked_hash_map_value_iterator.rs index f1bdbed3..dda27dd7 100644 --- a/rustjava-runtime/src/classes/java/util/linked_hash_map_value_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/linked_hash_map_value_iterator.rs @@ -48,6 +48,7 @@ impl LinkedHashMapValueIterator { ) .await?; - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/LinkedHashMap$Entry", "value", "Ljava/lang/Object;") + .await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_list.rs b/rustjava-runtime/src/classes/java/util/linked_list.rs index 0c1f2dbe..7cc263c9 100644 --- a/rustjava-runtime/src/classes/java/util/linked_list.rs +++ b/rustjava-runtime/src/classes/java/util/linked_list.rs @@ -72,12 +72,26 @@ impl LinkedList { .await? .into(); let header_next = header.clone(); - jvm.put_field(&mut header, "next", "Ljava/util/LinkedList$Entry;", header_next).await?; + jvm.put_field( + &mut header, + "java/util/LinkedList$Entry", + "next", + "Ljava/util/LinkedList$Entry;", + header_next, + ) + .await?; let header_previous = header.clone(); - jvm.put_field(&mut header, "previous", "Ljava/util/LinkedList$Entry;", header_previous) + jvm.put_field( + &mut header, + "java/util/LinkedList$Entry", + "previous", + "Ljava/util/LinkedList$Entry;", + header_previous, + ) + .await?; + jvm.put_field(&mut this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;", header) .await?; - jvm.put_field(&mut this, "header", "Ljava/util/LinkedList$Entry;", header).await?; - jvm.put_field(&mut this, "size", "I", 0).await + jvm.put_field(&mut this, "java/util/LinkedList", "size", "I", 0).await } async fn init_collection( @@ -97,59 +111,81 @@ impl LinkedList { } async fn add_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; - let first = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let first = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; Self::add_before(jvm, &this, element, first).await } async fn add_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let header = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; + let header = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; Self::add_before(jvm, &this, element, header).await } async fn get_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - if jvm.get_field::(&this, "size", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/LinkedList", "size", "I").await? == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await); } - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; - let first: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - jvm.get_field(&first, "element", "Ljava/lang/Object;").await + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let first: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + jvm.get_field(&first, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await } async fn get_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - if jvm.get_field::(&this, "size", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/LinkedList", "size", "I").await? == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await); } - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; - let last: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; - jvm.get_field(&last, "element", "Ljava/lang/Object;").await + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let last: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; + jvm.get_field(&last, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await } async fn remove_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - if jvm.get_field::(&this, "size", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/LinkedList", "size", "I").await? == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await); } - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; - let first = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let first = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; Self::remove_entry(jvm, &this, first).await } async fn remove_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - if jvm.get_field::(&this, "size", "I").await? == 0 { + if jvm.get_field::(&this, "java/util/LinkedList", "size", "I").await? == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await); } - let header: ClassInstanceRef = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; - let last = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let last = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; Self::remove_entry(jvm, &this, last).await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "java/util/LinkedList", "size", "I").await } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { let entry = Self::entry_at(jvm, &this, index).await?; - jvm.get_field(&entry, "element", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await } async fn set( @@ -160,20 +196,24 @@ impl LinkedList { element: ClassInstanceRef, ) -> Result> { let mut entry = Self::entry_at(jvm, &this, index).await?; - let old = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?; - jvm.put_field(&mut entry, "element", "Ljava/lang/Object;", element).await?; + let old = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;") + .await?; + jvm.put_field(&mut entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;", element) + .await?; Ok(old) } async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32, element: ClassInstanceRef) -> Result<()> { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?; if index < 0 || index > size { return Err(jvm .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}")) .await); } let successor = if index == size { - jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await? + jvm.get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await? } else { Self::entry_at(jvm, &this, index).await? }; @@ -181,7 +221,9 @@ impl LinkedList { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let header = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?; + let header = jvm + .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; Self::add_before(jvm, &this, element, header).await?; Ok(true) } @@ -192,10 +234,12 @@ impl LinkedList { } async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?; for index in 0..size { let entry = Self::entry_at(jvm, &this, index).await?; - let current: ClassInstanceRef = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?; + let current: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;") + .await?; let equal = if element.is_null() { current.is_null() } else { @@ -211,10 +255,12 @@ impl LinkedList { } async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?; for index in 0..size { let entry = Self::entry_at(jvm, &this, index).await?; - let current: ClassInstanceRef = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?; + let current: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;") + .await?; if (element.is_null() && current.is_null()) || (!element.is_null() && jvm @@ -228,10 +274,12 @@ impl LinkedList { } async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(&this, "size", "I").await?; + let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?; for index in (0..size).rev() { let entry = Self::entry_at(jvm, &this, index).await?; - let current: ClassInstanceRef = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?; + let current: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;") + .await?; if (element.is_null() && current.is_null()) || (!element.is_null() && jvm @@ -245,7 +293,7 @@ impl LinkedList { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - while jvm.get_field::(&this, "size", "I").await? > 0 { + while jvm.get_field::(&this, "java/util/LinkedList", "size", "I").await? > 0 { let _: ClassInstanceRef = jvm .invoke_virtual(&this, "java/util/LinkedList", "removeFirst", "()Ljava/lang/Object;", ()) .await?; @@ -275,23 +323,33 @@ impl LinkedList { } async fn entry_at(jvm: &Jvm, this: &ClassInstanceRef, index: i32) -> Result> { - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?; if index < 0 || index >= size { return Err(jvm .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}")) .await); } - let header: ClassInstanceRef = jvm.get_field(this, "header", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; if index < size / 2 { - let mut entry: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; + let mut entry: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; for _ in 0..index { - entry = jvm.get_field(&entry, "next", "Ljava/util/LinkedList$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; } Ok(entry) } else { - let mut entry: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let mut entry: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; for _ in (index + 1)..size { - entry = jvm.get_field(&entry, "previous", "Ljava/util/LinkedList$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; } Ok(entry) } @@ -303,7 +361,9 @@ impl LinkedList { element: ClassInstanceRef, mut successor: ClassInstanceRef, ) -> Result<()> { - let mut predecessor: ClassInstanceRef = jvm.get_field(&successor, "previous", "Ljava/util/LinkedList$Entry;").await?; + let mut predecessor: ClassInstanceRef = jvm + .get_field(&successor, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; let entry: ClassInstanceRef = jvm .new_class( "java/util/LinkedList$Entry", @@ -312,13 +372,25 @@ impl LinkedList { ) .await? .into(); - jvm.put_field(&mut predecessor, "next", "Ljava/util/LinkedList$Entry;", entry.clone()) - .await?; - jvm.put_field(&mut successor, "previous", "Ljava/util/LinkedList$Entry;", entry.clone()) - .await?; - let size: i32 = jvm.get_field(this, "size", "I").await?; + jvm.put_field( + &mut predecessor, + "java/util/LinkedList$Entry", + "next", + "Ljava/util/LinkedList$Entry;", + entry.clone(), + ) + .await?; + jvm.put_field( + &mut successor, + "java/util/LinkedList$Entry", + "previous", + "Ljava/util/LinkedList$Entry;", + entry.clone(), + ) + .await?; + let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?; let mut list = this.clone(); - jvm.put_field(&mut list, "size", "I", size + 1).await?; + jvm.put_field(&mut list, "java/util/LinkedList", "size", "I", size + 1).await?; Ok(()) } @@ -327,20 +399,54 @@ impl LinkedList { this: &ClassInstanceRef, mut entry: ClassInstanceRef, ) -> Result> { - let mut previous: ClassInstanceRef = jvm.get_field(&entry, "previous", "Ljava/util/LinkedList$Entry;").await?; - let mut next: ClassInstanceRef = jvm.get_field(&entry, "next", "Ljava/util/LinkedList$Entry;").await?; - jvm.put_field(&mut previous, "next", "Ljava/util/LinkedList$Entry;", next.clone()).await?; - jvm.put_field(&mut next, "previous", "Ljava/util/LinkedList$Entry;", previous).await?; - let element = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?; + let mut previous: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; + let mut next: ClassInstanceRef = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + jvm.put_field( + &mut previous, + "java/util/LinkedList$Entry", + "next", + "Ljava/util/LinkedList$Entry;", + next.clone(), + ) + .await?; + jvm.put_field( + &mut next, + "java/util/LinkedList$Entry", + "previous", + "Ljava/util/LinkedList$Entry;", + previous, + ) + .await?; + let element = jvm + .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;") + .await?; let null_object: ClassInstanceRef = None.into(); let null_entry: ClassInstanceRef = None.into(); - jvm.put_field(&mut entry, "element", "Ljava/lang/Object;", null_object).await?; - jvm.put_field(&mut entry, "next", "Ljava/util/LinkedList$Entry;", null_entry.clone()) + jvm.put_field(&mut entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;", null_object) .await?; - jvm.put_field(&mut entry, "previous", "Ljava/util/LinkedList$Entry;", null_entry).await?; - let size: i32 = jvm.get_field(this, "size", "I").await?; + jvm.put_field( + &mut entry, + "java/util/LinkedList$Entry", + "next", + "Ljava/util/LinkedList$Entry;", + null_entry.clone(), + ) + .await?; + jvm.put_field( + &mut entry, + "java/util/LinkedList$Entry", + "previous", + "Ljava/util/LinkedList$Entry;", + null_entry, + ) + .await?; + let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?; let mut list = this.clone(); - jvm.put_field(&mut list, "size", "I", size - 1).await?; + jvm.put_field(&mut list, "java/util/LinkedList", "size", "I", size - 1).await?; Ok(element) } } diff --git a/rustjava-runtime/src/classes/java/util/linked_list_entry.rs b/rustjava-runtime/src/classes/java/util/linked_list_entry.rs index 6698c80f..6a8f68a7 100644 --- a/rustjava-runtime/src/classes/java/util/linked_list_entry.rs +++ b/rustjava-runtime/src/classes/java/util/linked_list_entry.rs @@ -39,8 +39,17 @@ impl LinkedListEntry { previous: ClassInstanceRef, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "element", "Ljava/lang/Object;", element).await?; - jvm.put_field(&mut this, "next", "Ljava/util/LinkedList$Entry;", next).await?; - jvm.put_field(&mut this, "previous", "Ljava/util/LinkedList$Entry;", previous).await + jvm.put_field(&mut this, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;", element) + .await?; + jvm.put_field(&mut this, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;", next) + .await?; + jvm.put_field( + &mut this, + "java/util/LinkedList$Entry", + "previous", + "Ljava/util/LinkedList$Entry;", + previous, + ) + .await } } diff --git a/rustjava-runtime/src/classes/java/util/linked_list_itr.rs b/rustjava-runtime/src/classes/java/util/linked_list_itr.rs index b382dc85..5587d07c 100644 --- a/rustjava-runtime/src/classes/java/util/linked_list_itr.rs +++ b/rustjava-runtime/src/classes/java/util/linked_list_itr.rs @@ -42,80 +42,95 @@ impl LinkedListItr { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "list iterator index").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "list", "Ljava/util/LinkedList;", list).await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;", list) + .await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "lastReturned", "I", -1).await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; + let cursor: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await?; Ok(cursor < jvm.invoke_virtual::<_, i32>(&list, "java/util/LinkedList", "size", "()I", ()).await?) } async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; + let cursor: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await?; if cursor >= jvm.invoke_virtual::<_, i32>(&list, "java/util/LinkedList", "size", "()I", ()).await? { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList iterator exhausted").await); } let value = jvm .invoke_virtual(&list, "java/util/LinkedList", "get", "(I)Ljava/lang/Object;", (cursor,)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", cursor).await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "cursor", "I", cursor + 1) + .await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "lastReturned", "I", cursor) + .await?; Ok(value) } async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? > 0) + Ok(jvm.get_field::(&this, "java/util/LinkedList$ListItr", "cursor", "I").await? > 0) } async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await?; if cursor <= 0 { return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList iterator exhausted").await); } let index = cursor - 1; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; let value = jvm .invoke_virtual(&list, "java/util/LinkedList", "get", "(I)Ljava/lang/Object;", (index,)) .await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", index).await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "lastReturned", "I", index) + .await?; Ok(value) } async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "cursor", "I").await + jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await } async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? - 1) + Ok(jvm.get_field::(&this, "java/util/LinkedList$ListItr", "cursor", "I").await? - 1) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; let _: ClassInstanceRef = jvm .invoke_virtual(&list, "java/util/LinkedList", "remove", "(I)Ljava/lang/Object;", (last_returned,)) .await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await?; if last_returned < cursor { - jvm.put_field(&mut this, "cursor", "I", cursor - 1).await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "cursor", "I", cursor - 1) + .await?; } - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "lastReturned", "I", -1).await } async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -129,12 +144,15 @@ impl LinkedListItr { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/LinkedList;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/LinkedList$ListItr", "cursor", "I").await?; + let list: ClassInstanceRef = jvm + .get_field(&this, "java/util/LinkedList$ListItr", "list", "Ljava/util/LinkedList;") + .await?; let _: () = jvm .invoke_virtual(&list, "java/util/LinkedList", "add", "(ILjava/lang/Object;)V", (cursor, element)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "cursor", "I", cursor + 1) + .await?; + jvm.put_field(&mut this, "java/util/LinkedList$ListItr", "lastReturned", "I", -1).await } } diff --git a/rustjava-runtime/src/classes/java/util/locale.rs b/rustjava-runtime/src/classes/java/util/locale.rs index 9a26500c..d057ad03 100644 --- a/rustjava-runtime/src/classes/java/util/locale.rs +++ b/rustjava-runtime/src/classes/java/util/locale.rs @@ -564,9 +564,12 @@ impl Locale { let country = JavaLangString::from_rust_string(jvm, &country).await?; let variant = JavaLangString::from_rust_string(jvm, &variant).await?; - jvm.put_field(&mut this, "language", "Ljava/lang/String;", language).await?; - jvm.put_field(&mut this, "country", "Ljava/lang/String;", country).await?; - jvm.put_field(&mut this, "variant", "Ljava/lang/String;", variant).await?; + jvm.put_field(&mut this, "java/util/Locale", "language", "Ljava/lang/String;", language) + .await?; + jvm.put_field(&mut this, "java/util/Locale", "country", "Ljava/lang/String;", country) + .await?; + jvm.put_field(&mut this, "java/util/Locale", "variant", "Ljava/lang/String;", variant) + .await?; Ok(()) } @@ -648,25 +651,25 @@ impl Locale { async fn get_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::getLanguage({this:?})"); - jvm.get_field(&this, "language", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await } async fn get_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::getCountry({this:?})"); - jvm.get_field(&this, "country", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await } async fn get_variant(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::getVariant({this:?})"); - jvm.get_field(&this, "variant", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await } async fn get_iso3_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::getISO3Language({this:?})"); - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; let iso3 = match language.as_str() { "" => "", @@ -686,7 +689,7 @@ impl Locale { async fn get_iso3_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::getISO3Country({this:?})"); - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; let iso3 = match country.as_str() { "" => "", @@ -723,7 +726,7 @@ impl Locale { return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await); } - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; Ok(JavaLangString::from_rust_string(jvm, Self::display_language(&language)).await?.into()) @@ -746,7 +749,7 @@ impl Locale { return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await); } - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; Ok(JavaLangString::from_rust_string(jvm, Self::display_country(&country)).await?.into()) @@ -769,7 +772,7 @@ impl Locale { return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await); } - jvm.get_field(&this, "variant", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await } async fn get_display_name_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -789,9 +792,9 @@ impl Locale { return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await); } - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; - let variant: ClassInstanceRef = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let variant: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; @@ -862,12 +865,12 @@ impl Locale { let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let this_language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; - let this_country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; - let this_variant: ClassInstanceRef = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?; - let other_language: ClassInstanceRef = jvm.get_field(&other, "language", "Ljava/lang/String;").await?; - let other_country: ClassInstanceRef = jvm.get_field(&other, "country", "Ljava/lang/String;").await?; - let other_variant: ClassInstanceRef = jvm.get_field(&other, "variant", "Ljava/lang/String;").await?; + let this_language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let this_country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let this_variant: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?; + let other_language: ClassInstanceRef = jvm.get_field(&other, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let other_country: ClassInstanceRef = jvm.get_field(&other, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let other_variant: ClassInstanceRef = jvm.get_field(&other, "java/util/Locale", "variant", "Ljava/lang/String;").await?; let this_language = JavaLangString::to_rust_string(jvm, &this_language).await?; let this_country = JavaLangString::to_rust_string(jvm, &this_country).await?; @@ -882,9 +885,9 @@ impl Locale { async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Locale::hashCode({this:?})"); - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; - let variant: ClassInstanceRef = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let variant: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; @@ -900,9 +903,9 @@ impl Locale { async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::clone({this:?})"); - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; - let variant: ClassInstanceRef = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let variant: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; @@ -925,9 +928,9 @@ impl Locale { async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Locale::toString({this:?})"); - let language: ClassInstanceRef = jvm.get_field(&this, "language", "Ljava/lang/String;").await?; - let country: ClassInstanceRef = jvm.get_field(&this, "country", "Ljava/lang/String;").await?; - let variant: ClassInstanceRef = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?; + let language: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?; + let country: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?; + let variant: ClassInstanceRef = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?; let language = JavaLangString::to_rust_string(jvm, &language).await?; let country = JavaLangString::to_rust_string(jvm, &country).await?; diff --git a/rustjava-runtime/src/classes/java/util/logging/handler.rs b/rustjava-runtime/src/classes/java/util/logging/handler.rs index 8b123dad..aea26ca1 100644 --- a/rustjava-runtime/src/classes/java/util/logging/handler.rs +++ b/rustjava-runtime/src/classes/java/util/logging/handler.rs @@ -80,31 +80,35 @@ impl Handler { let level: ClassInstanceRef = jvm .get_static_field("java/util/logging/Level", "ALL", "Ljava/util/logging/Level;") .await?; - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await + jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level) + .await } async fn get_encoding(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Handler::getEncoding({this:?})"); - jvm.get_field(&this, "encoding", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;").await } async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Handler::getFilter({this:?})"); - jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await + jvm.get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;") + .await } async fn get_formatter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Handler::getFormatter({this:?})"); - jvm.get_field(&this, "formatter", "Ljava/util/logging/Formatter;").await + jvm.get_field(&this, "java/util/logging/Handler", "formatter", "Ljava/util/logging/Formatter;") + .await } async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Handler::getLevel({this:?})"); - jvm.get_field(&this, "level", "Ljava/util/logging/Level;").await + jvm.get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;") + .await } async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, record: ClassInstanceRef) -> Result { @@ -117,7 +121,9 @@ impl Handler { let record_level: ClassInstanceRef = jvm .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ()) .await?; - let handler_level: ClassInstanceRef = jvm.get_field(&this, "level", "Ljava/util/logging/Level;").await?; + let handler_level: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;") + .await?; let record_value: i32 = jvm .invoke_virtual(&record_level, "java/util/logging/Level", "intValue", "()I", ()) .await?; @@ -128,7 +134,9 @@ impl Handler { return Ok(false); } - let filter: ClassInstanceRef = jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await?; + let filter: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;") + .await?; if filter.is_null() { return Ok(true); } @@ -162,13 +170,15 @@ impl Handler { if !encoding.is_null() { OutputStreamWriter::validate_encoding(jvm, &encoding).await?; } - jvm.put_field(&mut this, "encoding", "Ljava/lang/String;", encoding).await + jvm.put_field(&mut this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;", encoding) + .await } async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, filter: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.logging.Handler::setFilter({this:?}, {filter:?})"); - jvm.put_field(&mut this, "filter", "Ljava/util/logging/Filter;", filter).await + jvm.put_field(&mut this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;", filter) + .await } async fn set_formatter( @@ -182,7 +192,14 @@ impl Handler { if formatter.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "formatter").await); } - jvm.put_field(&mut this, "formatter", "Ljava/util/logging/Formatter;", formatter).await + jvm.put_field( + &mut this, + "java/util/logging/Handler", + "formatter", + "Ljava/util/logging/Formatter;", + formatter, + ) + .await } async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, level: ClassInstanceRef) -> Result<()> { @@ -191,6 +208,7 @@ impl Handler { if level.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "level").await); } - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await + jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level) + .await } } diff --git a/rustjava-runtime/src/classes/java/util/logging/level.rs b/rustjava-runtime/src/classes/java/util/logging/level.rs index 7b2aa225..0e0a3174 100644 --- a/rustjava-runtime/src/classes/java/util/logging/level.rs +++ b/rustjava-runtime/src/classes/java/util/logging/level.rs @@ -202,8 +202,9 @@ impl Level { } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; - jvm.put_field(&mut this, "value", "I", value).await + jvm.put_field(&mut this, "java/util/logging/Level", "name", "Ljava/lang/String;", name) + .await?; + jvm.put_field(&mut this, "java/util/logging/Level", "value", "I", value).await } async fn parse(jvm: &Jvm, _: &mut RuntimeContext, name: ClassInstanceRef) -> Result> { @@ -262,13 +263,13 @@ impl Level { async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Level::getName({this:?})"); - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/Level", "name", "Ljava/lang/String;").await } async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.logging.Level::intValue({this:?})"); - jvm.get_field(&this, "value", "I").await + jvm.get_field(&this, "java/util/logging/Level", "value", "I").await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -279,20 +280,20 @@ impl Level { } let other: ClassInstanceRef = ClassInstanceRef::new(other.instance); - let value: i32 = jvm.get_field(&this, "value", "I").await?; - let other_value: i32 = jvm.get_field(&other, "value", "I").await?; + let value: i32 = jvm.get_field(&this, "java/util/logging/Level", "value", "I").await?; + let other_value: i32 = jvm.get_field(&other, "java/util/logging/Level", "value", "I").await?; Ok(value == other_value) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.logging.Level::hashCode({this:?})"); - jvm.get_field(&this, "value", "I").await + jvm.get_field(&this, "java/util/logging/Level", "value", "I").await } async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Level::toString({this:?})"); - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/Level", "name", "Ljava/lang/String;").await } } diff --git a/rustjava-runtime/src/classes/java/util/logging/log_manager.rs b/rustjava-runtime/src/classes/java/util/logging/log_manager.rs index ec72a99f..d2370667 100644 --- a/rustjava-runtime/src/classes/java/util/logging/log_manager.rs +++ b/rustjava-runtime/src/classes/java/util/logging/log_manager.rs @@ -86,7 +86,14 @@ impl LogManager { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let loggers: ClassInstanceRef = jvm.new_class("java/util/Hashtable", "()V", ()).await?.into(); - jvm.put_field(&mut this, "loggers", "Ljava/util/Hashtable;", loggers.clone()).await?; + jvm.put_field( + &mut this, + "java/util/logging/LogManager", + "loggers", + "Ljava/util/Hashtable;", + loggers.clone(), + ) + .await?; let root_name = JavaLangString::from_rust_string(jvm, "").await?; let resource_bundle_name: ClassInstanceRef = None.into(); @@ -101,8 +108,10 @@ impl LogManager { let info: ClassInstanceRef = jvm .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;") .await?; - jvm.put_field(&mut root, "level", "Ljava/util/logging/Level;", info).await?; - jvm.put_field(&mut root, "useParentHandlers", "Z", false).await?; + jvm.put_field(&mut root, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", info) + .await?; + jvm.put_field(&mut root, "java/util/logging/Logger", "useParentHandlers", "Z", false) + .await?; let console: ClassInstanceRef = jvm.new_class("java/util/logging/ConsoleHandler", "()V", ()).await?.into(); let _: () = jvm .invoke_virtual( @@ -122,7 +131,14 @@ impl LogManager { (root_name, root.clone()), ) .await?; - jvm.put_field(&mut this, "root", "Ljava/util/logging/Logger;", root.clone()).await?; + jvm.put_field( + &mut this, + "java/util/logging/LogManager", + "root", + "Ljava/util/logging/Logger;", + root.clone(), + ) + .await?; let global_name: ClassInstanceRef = jvm .get_static_field("java/util/logging/Logger", "GLOBAL_LOGGER_NAME", "Ljava/lang/String;") @@ -130,7 +146,8 @@ impl LogManager { let mut global: ClassInstanceRef = jvm .get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;") .await?; - jvm.put_field(&mut global, "parent", "Ljava/util/logging/Logger;", root).await?; + jvm.put_field(&mut global, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", root) + .await?; let _: ClassInstanceRef = jvm .invoke_virtual( &loggers, @@ -178,7 +195,9 @@ impl LogManager { name: ClassInstanceRef, logger: ClassInstanceRef, ) -> Result { - let loggers: ClassInstanceRef = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?; + let loggers: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;") + .await?; let existing: ClassInstanceRef = jvm .invoke_virtual( &loggers, @@ -214,14 +233,18 @@ impl LogManager { if name.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "name").await); } - let loggers: ClassInstanceRef = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?; + let loggers: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;") + .await?; jvm.invoke_virtual(&loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (name,)) .await } async fn get_logger_names(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.LogManager::getLoggerNames({this:?})"); - let loggers: ClassInstanceRef = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?; + let loggers: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;") + .await?; jvm.invoke_virtual(&loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ()) .await } @@ -237,7 +260,9 @@ impl LogManager { (), ) .await?; - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/logging/Logger;").await?; + let root: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;") + .await?; let length = jvm.array_length(&loggers).await?; let loggers: Vec> = jvm.load_array(&loggers, 0, length).await?; for logger in loggers { @@ -260,7 +285,9 @@ impl LogManager { } async fn snapshot_loggers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { - let loggers: ClassInstanceRef = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?; + let loggers: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;") + .await?; let values: ClassInstanceRef = jvm .invoke_virtual(&loggers, "java/util/Hashtable", "elements", "()Ljava/util/Enumeration;", ()) .await?; @@ -302,7 +329,9 @@ impl LogManager { ); } - let root: ClassInstanceRef = jvm.get_field(manager, "root", "Ljava/util/logging/Logger;").await?; + let root: ClassInstanceRef = jvm + .get_field(manager, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;") + .await?; for key in keys { let name: RustString = JavaLangString::to_rust_string(jvm, &key).await?; if name.is_empty() { @@ -330,7 +359,8 @@ impl LogManager { break; } } - jvm.put_field(&mut logger, "parent", "Ljava/util/logging/Logger;", parent).await?; + jvm.put_field(&mut logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", parent) + .await?; } Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/logging/log_record.rs b/rustjava-runtime/src/classes/java/util/logging/log_record.rs index e9ca8cae..c428f9aa 100644 --- a/rustjava-runtime/src/classes/java/util/logging/log_record.rs +++ b/rustjava-runtime/src/classes/java/util/logging/log_record.rs @@ -135,13 +135,18 @@ impl LogRecord { .invoke_static("java/util/logging/LogRecord", "allocateSequenceNumber", "()J", ()) .await?; let current_thread = jvm.current_java_thread(); - let thread_id: i64 = jvm.get_field(¤t_thread, "id", "J").await?; + let thread_id: i64 = jvm.get_field(¤t_thread, "java/lang/Thread", "id", "J").await?; - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await?; - jvm.put_field(&mut this, "message", "Ljava/lang/String;", message).await?; - jvm.put_field(&mut this, "sequenceNumber", "J", sequence_number).await?; - jvm.put_field(&mut this, "millis", "J", context.now() as i64).await?; - jvm.put_field(&mut this, "threadID", "I", thread_id as i32).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "level", "Ljava/util/logging/Level;", level) + .await?; + jvm.put_field(&mut this, "java/util/logging/LogRecord", "message", "Ljava/lang/String;", message) + .await?; + jvm.put_field(&mut this, "java/util/logging/LogRecord", "sequenceNumber", "J", sequence_number) + .await?; + jvm.put_field(&mut this, "java/util/logging/LogRecord", "millis", "J", context.now() as i64) + .await?; + jvm.put_field(&mut this, "java/util/logging/LogRecord", "threadID", "I", thread_id as i32) + .await } async fn allocate_sequence_number(jvm: &Jvm, _: &mut RuntimeContext) -> Result { @@ -152,15 +157,18 @@ impl LogRecord { } async fn get_logger_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "loggerName", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "loggerName", "Ljava/lang/String;") + .await } async fn set_logger_name(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, name: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "loggerName", "Ljava/lang/String;", name).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "loggerName", "Ljava/lang/String;", name) + .await } async fn get_resource_bundle(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "resourceBundle", "Ljava/util/ResourceBundle;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "resourceBundle", "Ljava/util/ResourceBundle;") + .await } async fn set_resource_bundle( @@ -169,11 +177,19 @@ impl LogRecord { mut this: ClassInstanceRef, bundle: ClassInstanceRef, ) -> Result<()> { - jvm.put_field(&mut this, "resourceBundle", "Ljava/util/ResourceBundle;", bundle).await + jvm.put_field( + &mut this, + "java/util/logging/LogRecord", + "resourceBundle", + "Ljava/util/ResourceBundle;", + bundle, + ) + .await } async fn get_resource_bundle_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "resourceBundleName", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "resourceBundleName", "Ljava/lang/String;") + .await } async fn set_resource_bundle_name( @@ -182,11 +198,13 @@ impl LogRecord { mut this: ClassInstanceRef, name: ClassInstanceRef, ) -> Result<()> { - jvm.put_field(&mut this, "resourceBundleName", "Ljava/lang/String;", name).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "resourceBundleName", "Ljava/lang/String;", name) + .await } async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "level", "Ljava/util/logging/Level;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "level", "Ljava/util/logging/Level;") + .await } async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, level: ClassInstanceRef) -> Result<()> { @@ -194,19 +212,22 @@ impl LogRecord { return Err(jvm.exception("java/lang/NullPointerException", "level").await); } - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "level", "Ljava/util/logging/Level;", level) + .await } async fn get_sequence_number(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "sequenceNumber", "J").await + jvm.get_field(&this, "java/util/logging/LogRecord", "sequenceNumber", "J").await } async fn set_sequence_number(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, sequence_number: i64) -> Result<()> { - jvm.put_field(&mut this, "sequenceNumber", "J", sequence_number).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "sequenceNumber", "J", sequence_number) + .await } async fn get_source_class_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "sourceClassName", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "sourceClassName", "Ljava/lang/String;") + .await } async fn set_source_class_name( @@ -215,11 +236,19 @@ impl LogRecord { mut this: ClassInstanceRef, source_class_name: ClassInstanceRef, ) -> Result<()> { - jvm.put_field(&mut this, "sourceClassName", "Ljava/lang/String;", source_class_name).await + jvm.put_field( + &mut this, + "java/util/logging/LogRecord", + "sourceClassName", + "Ljava/lang/String;", + source_class_name, + ) + .await } async fn get_source_method_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "sourceMethodName", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "sourceMethodName", "Ljava/lang/String;") + .await } async fn set_source_method_name( @@ -228,44 +257,54 @@ impl LogRecord { mut this: ClassInstanceRef, source_method_name: ClassInstanceRef, ) -> Result<()> { - jvm.put_field(&mut this, "sourceMethodName", "Ljava/lang/String;", source_method_name) - .await + jvm.put_field( + &mut this, + "java/util/logging/LogRecord", + "sourceMethodName", + "Ljava/lang/String;", + source_method_name, + ) + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "message", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "message", "Ljava/lang/String;").await } async fn set_message(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, message: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "message", "Ljava/lang/String;", message).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "message", "Ljava/lang/String;", message) + .await } async fn get_thread_id(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "threadID", "I").await + jvm.get_field(&this, "java/util/logging/LogRecord", "threadID", "I").await } async fn set_thread_id(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, thread_id: i32) -> Result<()> { - jvm.put_field(&mut this, "threadID", "I", thread_id).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "threadID", "I", thread_id).await } async fn get_millis(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "millis", "J").await + jvm.get_field(&this, "java/util/logging/LogRecord", "millis", "J").await } async fn set_millis(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, millis: i64) -> Result<()> { - jvm.put_field(&mut this, "millis", "J", millis).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "millis", "J", millis).await } async fn get_thrown(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "thrown", "Ljava/lang/Throwable;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "thrown", "Ljava/lang/Throwable;") + .await } async fn set_thrown(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, thrown: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "thrown", "Ljava/lang/Throwable;", thrown).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "thrown", "Ljava/lang/Throwable;", thrown) + .await } async fn get_parameters(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { - jvm.get_field(&this, "parameters", "[Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/logging/LogRecord", "parameters", "[Ljava/lang/Object;") + .await } async fn set_parameters( @@ -274,6 +313,7 @@ impl LogRecord { mut this: ClassInstanceRef, parameters: ClassInstanceRef>, ) -> Result<()> { - jvm.put_field(&mut this, "parameters", "[Ljava/lang/Object;", parameters).await + jvm.put_field(&mut this, "java/util/logging/LogRecord", "parameters", "[Ljava/lang/Object;", parameters) + .await } } diff --git a/rustjava-runtime/src/classes/java/util/logging/logger.rs b/rustjava-runtime/src/classes/java/util/logging/logger.rs index 235ad64e..f322d6ed 100644 --- a/rustjava-runtime/src/classes/java/util/logging/logger.rs +++ b/rustjava-runtime/src/classes/java/util/logging/logger.rs @@ -299,11 +299,20 @@ impl Logger { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let handlers = jvm.new_class("java/util/Vector", "()V", ()).await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; - jvm.put_field(&mut this, "handlers", "Ljava/util/Vector;", handlers).await?; - jvm.put_field(&mut this, "useParentHandlers", "Z", true).await?; - jvm.put_field(&mut this, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name) - .await + jvm.put_field(&mut this, "java/util/logging/Logger", "name", "Ljava/lang/String;", name) + .await?; + jvm.put_field(&mut this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;", handlers) + .await?; + jvm.put_field(&mut this, "java/util/logging/Logger", "useParentHandlers", "Z", true) + .await?; + jvm.put_field( + &mut this, + "java/util/logging/Logger", + "resourceBundleName", + "Ljava/lang/String;", + resource_bundle_name, + ) + .await } async fn get_logger(jvm: &Jvm, _: &mut RuntimeContext, name: ClassInstanceRef) -> Result> { @@ -397,10 +406,18 @@ impl Logger { return Ok(()); } - let current: ClassInstanceRef = jvm.get_field(&this, "resourceBundleName", "Ljava/lang/String;").await?; + let current: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/Logger", "resourceBundleName", "Ljava/lang/String;") + .await?; if current.is_null() { return jvm - .put_field(&mut this, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name) + .put_field( + &mut this, + "java/util/logging/Logger", + "resourceBundleName", + "Ljava/lang/String;", + resource_bundle_name, + ) .await; } if JavaLangString::to_rust_string(jvm, ¤t).await? != JavaLangString::to_rust_string(jvm, &resource_bundle_name).await? { @@ -453,7 +470,8 @@ impl Logger { (root_name,), ) .await?; - jvm.put_field(&mut logger, "parent", "Ljava/util/logging/Logger;", root).await?; + jvm.put_field(&mut logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", root) + .await?; Ok(logger) } @@ -465,32 +483,37 @@ impl Logger { async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getName({this:?})"); - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/Logger", "name", "Ljava/lang/String;").await } async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getFilter({this:?})"); - jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await + jvm.get_field(&this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;") + .await } async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, filter: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.logging.Logger::setFilter({this:?}, {filter:?})"); - jvm.put_field(&mut this, "filter", "Ljava/util/logging/Filter;", filter).await + jvm.put_field(&mut this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;", filter) + .await } async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getLevel({this:?})"); - jvm.get_field(&this, "level", "Ljava/util/logging/Level;").await + jvm.get_field(&this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;") + .await } async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, level: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.logging.Logger::setLevel({this:?}, {level:?})"); - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await + jvm.put_field(&mut this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", level) + .await } async fn get_parent(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getParent({this:?})"); - jvm.get_field(&this, "parent", "Ljava/util/logging/Logger;").await + jvm.get_field(&this, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;") + .await } async fn set_parent(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, parent: ClassInstanceRef) -> Result<()> { @@ -498,17 +521,19 @@ impl Logger { if parent.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "parent").await); } - jvm.put_field(&mut this, "parent", "Ljava/util/logging/Logger;", parent).await + jvm.put_field(&mut this, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", parent) + .await } async fn get_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.logging.Logger::getUseParentHandlers({this:?})"); - jvm.get_field(&this, "useParentHandlers", "Z").await + jvm.get_field(&this, "java/util/logging/Logger", "useParentHandlers", "Z").await } async fn set_use_parent_handlers(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: bool) -> Result<()> { tracing::debug!("java.util.logging.Logger::setUseParentHandlers({this:?}, {value})"); - jvm.put_field(&mut this, "useParentHandlers", "Z", value).await + jvm.put_field(&mut this, "java/util/logging/Logger", "useParentHandlers", "Z", value) + .await } async fn add_handler(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, handler: ClassInstanceRef) -> Result<()> { @@ -516,7 +541,7 @@ impl Logger { if handler.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "handler").await); } - let handlers: ClassInstanceRef = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?; + let handlers: ClassInstanceRef = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?; jvm.invoke_virtual(&handlers, "java/util/Vector", "addElement", "(Ljava/lang/Object;)V", (handler,)) .await } @@ -526,7 +551,7 @@ impl Logger { if handler.is_null() { return Ok(()); } - let handlers: ClassInstanceRef = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?; + let handlers: ClassInstanceRef = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?; let _: bool = jvm .invoke_virtual(&handlers, "java/util/Vector", "removeElement", "(Ljava/lang/Object;)Z", (handler,)) .await?; @@ -535,7 +560,7 @@ impl Logger { async fn get_handlers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { tracing::debug!("java.util.logging.Logger::getHandlers({this:?})"); - let handlers: ClassInstanceRef = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?; + let handlers: ClassInstanceRef = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?; let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?; let mut result: ClassInstanceRef> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into(); for index in 0..size { @@ -556,11 +581,15 @@ impl Logger { let requested: i32 = jvm.invoke_virtual(&level, "java/util/logging/Level", "intValue", "()I", ()).await?; let mut logger = this; let effective = loop { - let configured: ClassInstanceRef = jvm.get_field(&logger, "level", "Ljava/util/logging/Level;").await?; + let configured: ClassInstanceRef = jvm + .get_field(&logger, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;") + .await?; if !configured.is_null() { break jvm.invoke_virtual(&configured, "java/util/logging/Level", "intValue", "()I", ()).await?; } - let parent: ClassInstanceRef = jvm.get_field(&logger, "parent", "Ljava/util/logging/Logger;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;") + .await?; if parent.is_null() { let info: ClassInstanceRef = jvm .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;") @@ -588,7 +617,9 @@ impl Logger { return Ok(()); } - let filter: ClassInstanceRef = jvm.get_field(&this, "filter", "Ljava/util/logging/Filter;").await?; + let filter: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/Logger", "filter", "Ljava/util/logging/Filter;") + .await?; if !filter.is_null() && !jvm .invoke_virtual::<_, bool>( @@ -607,8 +638,9 @@ impl Logger { .invoke_virtual(&record, "java/util/logging/LogRecord", "getLoggerName", "()Ljava/lang/String;", ()) .await?; if logger_name.is_null() { - let name: ClassInstanceRef = jvm.get_field(&this, "name", "Ljava/lang/String;").await?; - jvm.put_field(&mut record, "loggerName", "Ljava/lang/String;", name).await?; + let name: ClassInstanceRef = jvm.get_field(&this, "java/util/logging/Logger", "name", "Ljava/lang/String;").await?; + jvm.put_field(&mut record, "java/util/logging/LogRecord", "loggerName", "Ljava/lang/String;", name) + .await?; } let mut logger = this; @@ -630,11 +662,13 @@ impl Logger { .await?; } - let use_parent: bool = jvm.get_field(&logger, "useParentHandlers", "Z").await?; + let use_parent: bool = jvm.get_field(&logger, "java/util/logging/Logger", "useParentHandlers", "Z").await?; if !use_parent { break; } - let parent: ClassInstanceRef = jvm.get_field(&logger, "parent", "Ljava/util/logging/Logger;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;") + .await?; if parent.is_null() { break; } @@ -1170,16 +1204,18 @@ impl Logger { async fn get_resource_bundle_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getResourceBundleName({this:?})"); - jvm.get_field(&this, "resourceBundleName", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/logging/Logger", "resourceBundleName", "Ljava/lang/String;") + .await } async fn get_resource_bundle(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.logging.Logger::getResourceBundle({this:?})"); - jvm.get_field(&this, "resourceBundle", "Ljava/util/ResourceBundle;").await + jvm.get_field(&this, "java/util/logging/Logger", "resourceBundle", "Ljava/util/ResourceBundle;") + .await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, root: bool) -> Result>> { - let handlers: ClassInstanceRef = jvm.get_field(&this, "handlers", "Ljava/util/Vector;").await?; + let handlers: ClassInstanceRef = jvm.get_field(&this, "java/util/logging/Logger", "handlers", "Ljava/util/Vector;").await?; let size: i32 = jvm.invoke_virtual(&handlers, "java/util/Vector", "size", "()I", ()).await?; let mut removed: ClassInstanceRef> = jvm.instantiate_array("Ljava/util/logging/Handler;", size as usize).await?.into(); for index in 0..size { @@ -1196,7 +1232,8 @@ impl Logger { } else { None.into() }; - jvm.put_field(&mut this, "level", "Ljava/util/logging/Level;", level).await?; + jvm.put_field(&mut this, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", level) + .await?; Ok(removed) } @@ -1248,21 +1285,48 @@ impl Logger { .await? .into(); if !parameters.is_null() { - jvm.put_field(&mut record, "parameters", "[Ljava/lang/Object;", parameters).await?; + jvm.put_field( + &mut record, + "java/util/logging/LogRecord", + "parameters", + "[Ljava/lang/Object;", + parameters, + ) + .await?; } if !thrown.is_null() { - jvm.put_field(&mut record, "thrown", "Ljava/lang/Throwable;", thrown).await?; + jvm.put_field(&mut record, "java/util/logging/LogRecord", "thrown", "Ljava/lang/Throwable;", thrown) + .await?; } if !source_class.is_null() { - jvm.put_field(&mut record, "sourceClassName", "Ljava/lang/String;", source_class).await?; + jvm.put_field( + &mut record, + "java/util/logging/LogRecord", + "sourceClassName", + "Ljava/lang/String;", + source_class, + ) + .await?; } if !source_method.is_null() { - jvm.put_field(&mut record, "sourceMethodName", "Ljava/lang/String;", source_method) - .await?; + jvm.put_field( + &mut record, + "java/util/logging/LogRecord", + "sourceMethodName", + "Ljava/lang/String;", + source_method, + ) + .await?; } if !resource_bundle_name.is_null() { - jvm.put_field(&mut record, "resourceBundleName", "Ljava/lang/String;", resource_bundle_name) - .await?; + jvm.put_field( + &mut record, + "java/util/logging/LogRecord", + "resourceBundleName", + "Ljava/lang/String;", + resource_bundle_name, + ) + .await?; } jvm.invoke_virtual(&this, "java/util/logging/Logger", "log", "(Ljava/util/logging/LogRecord;)V", (record,)) .await diff --git a/rustjava-runtime/src/classes/java/util/logging/stream_handler.rs b/rustjava-runtime/src/classes/java/util/logging/stream_handler.rs index f5813591..50e201fd 100644 --- a/rustjava-runtime/src/classes/java/util/logging/stream_handler.rs +++ b/rustjava-runtime/src/classes/java/util/logging/stream_handler.rs @@ -87,7 +87,8 @@ impl StreamHandler { let _: () = jvm .invoke_special(&this, "java/util/logging/Handler", "setLevel", "(Ljava/util/logging/Level;)V", (level,)) .await?; - jvm.put_field(&mut this, "headerWritten", "Z", false).await + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false) + .await } async fn init_with_output( @@ -129,7 +130,9 @@ impl StreamHandler { async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.logging.StreamHandler::close({this:?})"); - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; if writer.is_null() { return Ok(()); } @@ -139,15 +142,26 @@ impl StreamHandler { let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "close", "()V", ()).await?; let output: ClassInstanceRef = None.into(); let writer: ClassInstanceRef = None.into(); - jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?; - jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?; - jvm.put_field(&mut this, "headerWritten", "Z", false).await + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output) + .await?; + jvm.put_field( + &mut this, + "java/util/logging/StreamHandler", + "writer", + "Ljava/io/OutputStreamWriter;", + writer, + ) + .await?; + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false) + .await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.logging.StreamHandler::flush({this:?})"); - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; if writer.is_null() { return Ok(()); } @@ -157,7 +171,9 @@ impl StreamHandler { async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, record: ClassInstanceRef) -> Result { tracing::debug!("java.util.logging.StreamHandler::isLoggable({this:?}, {record:?})"); - let output: ClassInstanceRef = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?; + let output: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;") + .await?; if output.is_null() || record.is_null() { return Ok(false); } @@ -205,7 +221,9 @@ impl StreamHandler { .await?; return Ok(()); } - let formatter: ClassInstanceRef = jvm.get_field(&this, "formatter", "Ljava/util/logging/Formatter;").await?; + let formatter: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;") + .await?; let formatted: ClassInstanceRef = match jvm .invoke_virtual( &formatter, @@ -235,7 +253,9 @@ impl StreamHandler { return Ok(()); } }; - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; if let Err(JavaError::JavaException(exception)) = jvm .invoke_virtual::<_, ()>(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (formatted,)) .await @@ -271,12 +291,16 @@ impl StreamHandler { ) .await?; - let output: ClassInstanceRef = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?; + let output: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;") + .await?; if output.is_null() { return Ok(()); } - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?; let writer: ClassInstanceRef = if encoding.is_null() { jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output,)) @@ -291,7 +315,14 @@ impl StreamHandler { .await? .into() }; - jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await + jvm.put_field( + &mut this, + "java/util/logging/StreamHandler", + "writer", + "Ljava/io/OutputStreamWriter;", + writer, + ) + .await } async fn set_output_stream( @@ -306,7 +337,9 @@ impl StreamHandler { return Err(jvm.exception("java/lang/NullPointerException", "output").await); } - let current_writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let current_writer: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; if !current_writer.is_null() { Self::write_tail(jvm, &this).await?; let _: () = jvm @@ -317,7 +350,9 @@ impl StreamHandler { .await?; } - let encoding: ClassInstanceRef = jvm.get_field(&this, "encoding", "Ljava/lang/String;").await?; + let encoding: ClassInstanceRef = jvm + .get_field(&this, "java/util/logging/StreamHandler", "encoding", "Ljava/lang/String;") + .await?; let writer: ClassInstanceRef = if encoding.is_null() { jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output.clone(),)) .await? @@ -331,17 +366,31 @@ impl StreamHandler { .await? .into() }; - jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?; - jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?; - jvm.put_field(&mut this, "headerWritten", "Z", false).await + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output) + .await?; + jvm.put_field( + &mut this, + "java/util/logging/StreamHandler", + "writer", + "Ljava/io/OutputStreamWriter;", + writer, + ) + .await?; + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false) + .await } async fn write_head(jvm: &Jvm, this: &ClassInstanceRef) -> Result<()> { - if jvm.get_field::(this, "headerWritten", "Z").await? { + if jvm + .get_field::(this, "java/util/logging/StreamHandler", "headerWritten", "Z") + .await? + { return Ok(()); } - let formatter: ClassInstanceRef = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?; + let formatter: ClassInstanceRef = jvm + .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;") + .await?; let head: ClassInstanceRef = jvm .invoke_virtual( &formatter, @@ -351,17 +400,22 @@ impl StreamHandler { (this.clone(),), ) .await?; - let writer: ClassInstanceRef = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; let _: () = jvm .invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (head,)) .await?; let mut this = this.clone(); - jvm.put_field(&mut this, "headerWritten", "Z", true).await + jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", true) + .await } async fn write_tail(jvm: &Jvm, this: &ClassInstanceRef) -> Result<()> { Self::write_head(jvm, this).await?; - let formatter: ClassInstanceRef = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?; + let formatter: ClassInstanceRef = jvm + .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;") + .await?; let tail: ClassInstanceRef = jvm .invoke_virtual( &formatter, @@ -371,7 +425,9 @@ impl StreamHandler { (this.clone(),), ) .await?; - let writer: ClassInstanceRef = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?; + let writer: ClassInstanceRef = jvm + .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;") + .await?; jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (tail,)) .await } diff --git a/rustjava-runtime/src/classes/java/util/missing_format_argument_exception.rs b/rustjava-runtime/src/classes/java/util/missing_format_argument_exception.rs index 26439659..66fbb2a0 100644 --- a/rustjava-runtime/src/classes/java/util/missing_format_argument_exception.rs +++ b/rustjava-runtime/src/classes/java/util/missing_format_argument_exception.rs @@ -35,15 +35,25 @@ impl MissingFormatArgumentException { return Err(jvm.exception("java/lang/NullPointerException", "specifier is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "specifier", "Ljava/lang/String;", specifier).await + jvm.put_field( + &mut this, + "java/util/MissingFormatArgumentException", + "specifier", + "Ljava/lang/String;", + specifier, + ) + .await } async fn get_format_specifier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "specifier", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/MissingFormatArgumentException", "specifier", "Ljava/lang/String;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let specifier: ClassInstanceRef = jvm.get_field(&this, "specifier", "Ljava/lang/String;").await?; + let specifier: ClassInstanceRef = jvm + .get_field(&this, "java/util/MissingFormatArgumentException", "specifier", "Ljava/lang/String;") + .await?; JavaLangString::from_rust_string( jvm, &alloc::format!("Format specifier '{}'", JavaLangString::to_rust_string(jvm, &specifier).await?), diff --git a/rustjava-runtime/src/classes/java/util/missing_format_width_exception.rs b/rustjava-runtime/src/classes/java/util/missing_format_width_exception.rs index fb6c19d8..442754f1 100644 --- a/rustjava-runtime/src/classes/java/util/missing_format_width_exception.rs +++ b/rustjava-runtime/src/classes/java/util/missing_format_width_exception.rs @@ -40,10 +40,18 @@ impl MissingFormatWidthException { return Err(jvm.exception("java/lang/NullPointerException", "specifier is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "specifier", "Ljava/lang/String;", specifier).await + jvm.put_field( + &mut this, + "java/util/MissingFormatWidthException", + "specifier", + "Ljava/lang/String;", + specifier, + ) + .await } async fn get_format_specifier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "specifier", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/MissingFormatWidthException", "specifier", "Ljava/lang/String;") + .await } } diff --git a/rustjava-runtime/src/classes/java/util/properties.rs b/rustjava-runtime/src/classes/java/util/properties.rs index bdf00f7d..cb7cb55d 100644 --- a/rustjava-runtime/src/classes/java/util/properties.rs +++ b/rustjava-runtime/src/classes/java/util/properties.rs @@ -80,7 +80,8 @@ impl Properties { tracing::debug!("java.util.Properties::({this:?}, {defaults:?})"); let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "", "()V", ()).await?; - jvm.put_field(&mut this, "defaults", "Ljava/util/Properties;", defaults).await + jvm.put_field(&mut this, "java/util/Properties", "defaults", "Ljava/util/Properties;", defaults) + .await } async fn get_property( @@ -104,7 +105,7 @@ impl Properties { return Ok(ClassInstanceRef::new(result.instance)); } - let defaults: ClassInstanceRef = jvm.get_field(&this, "defaults", "Ljava/util/Properties;").await?; + let defaults: ClassInstanceRef = jvm.get_field(&this, "java/util/Properties", "defaults", "Ljava/util/Properties;").await?; if defaults.is_null() { Ok(None.into()) } else { @@ -389,7 +390,9 @@ impl Properties { let mut current = this.clone(); while !current.is_null() { layers.push(current.clone()); - current = jvm.get_field(¤t, "defaults", "Ljava/util/Properties;").await?; + current = jvm + .get_field(¤t, "java/util/Properties", "defaults", "Ljava/util/Properties;") + .await?; } for layer in layers.into_iter().rev() { diff --git a/rustjava-runtime/src/classes/java/util/random.rs b/rustjava-runtime/src/classes/java/util/random.rs index 46a99a41..56ae8d93 100644 --- a/rustjava-runtime/src/classes/java/util/random.rs +++ b/rustjava-runtime/src/classes/java/util/random.rs @@ -70,10 +70,10 @@ impl Random { async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, bits: i32) -> Result { tracing::debug!("java.util.Random::next({this:?}, {bits:?})"); - let seed: i64 = jvm.get_field(&this, "seed", "J").await?; + let seed: i64 = jvm.get_field(&this, "java/util/Random", "seed", "J").await?; let next_seed = seed.wrapping_mul(0x5DEECE66D).wrapping_add(0xB) & 0xFFFFFFFFFFFF; - jvm.put_field(&mut this, "seed", "J", next_seed).await?; + jvm.put_field(&mut this, "java/util/Random", "seed", "J", next_seed).await?; let value = (next_seed as u64).wrapping_shr(((48 - bits) & 63) as u32) as i32; @@ -163,10 +163,10 @@ impl Random { async fn next_gaussian(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Random::nextGaussian({this:?})"); - let have_next_next_gaussian: bool = jvm.get_field(&this, "haveNextNextGaussian", "Z").await?; + let have_next_next_gaussian: bool = jvm.get_field(&this, "java/util/Random", "haveNextNextGaussian", "Z").await?; if have_next_next_gaussian { - let next_next_gaussian: f64 = jvm.get_field(&this, "nextNextGaussian", "D").await?; - jvm.put_field(&mut this, "haveNextNextGaussian", "Z", false).await?; + let next_next_gaussian: f64 = jvm.get_field(&this, "java/util/Random", "nextNextGaussian", "D").await?; + jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?; return Ok(next_next_gaussian); } @@ -179,8 +179,9 @@ impl Random { } }; let multiplier = libm::sqrt(-2.0 * libm::log(radius_squared) / radius_squared); - jvm.put_field(&mut this, "nextNextGaussian", "D", second * multiplier).await?; - jvm.put_field(&mut this, "haveNextNextGaussian", "Z", true).await?; + jvm.put_field(&mut this, "java/util/Random", "nextNextGaussian", "D", second * multiplier) + .await?; + jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", true).await?; Ok(first * multiplier) } @@ -189,8 +190,8 @@ impl Random { let seed = (seed ^ 0x5DEECE66D) & ((1 << 48) - 1); - jvm.put_field(&mut this, "seed", "J", seed).await?; - jvm.put_field(&mut this, "haveNextNextGaussian", "Z", false).await?; + jvm.put_field(&mut this, "java/util/Random", "seed", "J", seed).await?; + jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?; Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/regex/matcher.rs b/rustjava-runtime/src/classes/java/util/regex/matcher.rs index c39df2b0..28cdf6f4 100644 --- a/rustjava-runtime/src/classes/java/util/regex/matcher.rs +++ b/rustjava-runtime/src/classes/java/util/regex/matcher.rs @@ -108,36 +108,47 @@ impl Matcher { return Err(jvm.exception("java/lang/NullPointerException", "input is null").await); } - let source: ClassInstanceRef = jvm.get_field(&pattern, "pattern", "Ljava/lang/String;").await?; - let flags: i32 = jvm.get_field(&pattern, "flags", "I").await?; + let source: ClassInstanceRef = jvm + .get_field(&pattern, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;") + .await?; + let flags: i32 = jvm.get_field(&pattern, "java/util/regex/Pattern", "flags", "I").await?; let source_text = JavaLangString::to_rust_string(jvm, &source).await?; let regex = Pattern::build_regex(jvm, &source_text, &source, flags, false).await?; let mut groups = jvm.instantiate_array("I", regex.captures_len() * 2).await?; jvm.store_array(&mut groups, 0, vec![-1i32; regex.captures_len() * 2]).await?; - jvm.put_field(&mut this, "parentPattern", "Ljava/util/regex/Pattern;", pattern).await?; - jvm.put_field(&mut this, "text", "Ljava/lang/CharSequence;", input).await?; - jvm.put_field(&mut this, "groups", "[I", groups).await?; - jvm.put_field(&mut this, "searchPosition", "I", 0).await?; - jvm.put_field(&mut this, "appendPosition", "I", 0).await?; - jvm.put_field(&mut this, "hasMatch", "Z", false).await + jvm.put_field( + &mut this, + "java/util/regex/Matcher", + "parentPattern", + "Ljava/util/regex/Pattern;", + pattern, + ) + .await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;", input) + .await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "groups", "[I", groups).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "searchPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "appendPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "hasMatch", "Z", false).await } async fn pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.Matcher::pattern({this:?})"); - jvm.get_field(&this, "parentPattern", "Ljava/util/regex/Pattern;").await + jvm.get_field(&this, "java/util/regex/Matcher", "parentPattern", "Ljava/util/regex/Pattern;") + .await } async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.Matcher::reset({this:?})"); - let mut groups: ClassInstanceRef> = jvm.get_field(&this, "groups", "[I").await?; + let mut groups: ClassInstanceRef> = jvm.get_field(&this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(&mut this, "searchPosition", "I", 0).await?; - jvm.put_field(&mut this, "appendPosition", "I", 0).await?; - jvm.put_field(&mut this, "hasMatch", "Z", false).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "searchPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "appendPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; Ok(this) } @@ -153,13 +164,14 @@ impl Matcher { return Err(jvm.exception("java/lang/NullPointerException", "input is null").await); } - jvm.put_field(&mut this, "text", "Ljava/lang/CharSequence;", input).await?; - let mut groups: ClassInstanceRef> = jvm.get_field(&this, "groups", "[I").await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;", input) + .await?; + let mut groups: ClassInstanceRef> = jvm.get_field(&this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(&mut this, "searchPosition", "I", 0).await?; - jvm.put_field(&mut this, "appendPosition", "I", 0).await?; - jvm.put_field(&mut this, "hasMatch", "Z", false).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "searchPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "appendPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; Ok(this) } @@ -178,21 +190,21 @@ impl Matcher { async fn find(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.util.regex.Matcher::find({this:?})"); - let search_position: i32 = jvm.get_field(&this, "searchPosition", "I").await?; + let search_position: i32 = jvm.get_field(&this, "java/util/regex/Matcher", "searchPosition", "I").await?; if search_position == -1 { return Ok(false); } - let has_match: bool = jvm.get_field(&this, "hasMatch", "Z").await?; + let has_match: bool = jvm.get_field(&this, "java/util/regex/Matcher", "hasMatch", "Z").await?; if has_match { - let groups: ClassInstanceRef> = jvm.get_field(&this, "groups", "[I").await?; + let groups: ClassInstanceRef> = jvm.get_field(&this, "java/util/regex/Matcher", "groups", "[I").await?; let range: Vec = jvm.load_array(&groups, 0, 2).await?; if range[0] == range[1] && range[1] == search_position { let length = jvm.array_length(&groups).await?; let mut groups = groups; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(&mut this, "searchPosition", "I", -1).await?; - jvm.put_field(&mut this, "hasMatch", "Z", false).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "searchPosition", "I", -1).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; return Ok(false); } } @@ -214,7 +226,9 @@ impl Matcher { if start < 0 { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Illegal start index").await); } - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; let length: i32 = jvm.invoke_virtual(&text, &text.class_definition().name(), "length", "()I", ()).await?; if start > length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Illegal start index").await); @@ -255,7 +269,9 @@ impl Matcher { tracing::debug!("java.util.regex.Matcher::group({this:?})"); let (start, end) = Self::group_range(jvm, &this, 0).await?; - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; let group: ClassInstanceRef = jvm .invoke_virtual( &text, @@ -276,7 +292,9 @@ impl Matcher { if start < 0 { return Ok(None.into()); } - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; let group: ClassInstanceRef = jvm .invoke_virtual( &text, @@ -293,7 +311,7 @@ impl Matcher { async fn group_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.regex.Matcher::groupCount({this:?})"); - let groups: ClassInstanceRef> = jvm.get_field(&this, "groups", "[I").await?; + let groups: ClassInstanceRef> = jvm.get_field(&this, "java/util/regex/Matcher", "groups", "[I").await?; Ok(jvm.array_length(&groups).await? as i32 / 2 - 1) } @@ -306,16 +324,18 @@ impl Matcher { ) -> Result> { tracing::debug!("java.util.regex.Matcher::appendReplacement({this:?}, {buffer:?}, {replacement:?})"); - let has_match: bool = jvm.get_field(&this, "hasMatch", "Z").await?; + let has_match: bool = jvm.get_field(&this, "java/util/regex/Matcher", "hasMatch", "Z").await?; if !has_match { return Err(jvm.exception("java/lang/IllegalStateException", "No match available").await); } let expanded = Self::expand_replacement(jvm, &this, &replacement).await?; - let groups: ClassInstanceRef> = jvm.get_field(&this, "groups", "[I").await?; + let groups: ClassInstanceRef> = jvm.get_field(&this, "java/util/regex/Matcher", "groups", "[I").await?; let match_range: Vec = jvm.load_array(&groups, 0, 2).await?; - let append_position: i32 = jvm.get_field(&this, "appendPosition", "I").await?; - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let append_position: i32 = jvm.get_field(&this, "java/util/regex/Matcher", "appendPosition", "I").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; let prefix: ClassInstanceRef = jvm .invoke_virtual( &text, @@ -351,7 +371,8 @@ impl Matcher { (expanded,), ) .await?; - jvm.put_field(&mut this, "appendPosition", "I", match_range[1]).await?; + jvm.put_field(&mut this, "java/util/regex/Matcher", "appendPosition", "I", match_range[1]) + .await?; Ok(this) } @@ -367,8 +388,10 @@ impl Matcher { return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await); } - let append_position: i32 = jvm.get_field(&this, "appendPosition", "I").await?; - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let append_position: i32 = jvm.get_field(&this, "java/util/regex/Matcher", "appendPosition", "I").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; let length: i32 = jvm.invoke_virtual(&text, &text.class_definition().name(), "length", "()I", ()).await?; let tail: ClassInstanceRef = jvm .invoke_virtual( @@ -404,7 +427,9 @@ impl Matcher { .invoke_virtual(&this, "java/util/regex/Matcher", "reset", "()Ljava/util/regex/Matcher;", ()) .await?; if !jvm.invoke_virtual::<_, bool>(&this, "java/util/regex/Matcher", "find", "()Z", ()).await? { - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; return jvm .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await; @@ -450,7 +475,9 @@ impl Matcher { .invoke_virtual(&this, "java/util/regex/Matcher", "reset", "()Ljava/util/regex/Matcher;", ()) .await?; if !jvm.invoke_virtual::<_, bool>(&this, "java/util/regex/Matcher", "find", "()Z", ()).await? { - let text: ClassInstanceRef = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;") + .await?; return jvm .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await; @@ -480,12 +507,12 @@ impl Matcher { } async fn group_range(jvm: &Jvm, this: &ClassInstanceRef, group: i32) -> Result<(i32, i32)> { - let has_match: bool = jvm.get_field(this, "hasMatch", "Z").await?; + let has_match: bool = jvm.get_field(this, "java/util/regex/Matcher", "hasMatch", "Z").await?; if !has_match { return Err(jvm.exception("java/lang/IllegalStateException", "No match found").await); } - let groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; if group < 0 || group as usize >= length / 2 { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "No group with this index").await); @@ -500,10 +527,10 @@ impl Matcher { } let replacement = JavaLangString::to_utf16(jvm, replacement).await?; - let groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; let group_count = jvm.array_length(&groups).await? / 2 - 1; let ranges: Vec = jvm.load_array(&groups, 0, (group_count + 1) * 2).await?; - let text: ClassInstanceRef = jvm.get_field(this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm.get_field(this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;").await?; let mut expanded = Vec::new(); let mut index = 0; @@ -573,15 +600,15 @@ impl Matcher { async fn execute_match(jvm: &Jvm, this: &mut ClassInstanceRef, mode: MatchMode) -> Result { if let MatchMode::Find { start, reset: true } = mode { - let mut groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let mut groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(this, "searchPosition", "I", start).await?; - jvm.put_field(this, "appendPosition", "I", 0).await?; - jvm.put_field(this, "hasMatch", "Z", false).await?; + jvm.put_field(this, "java/util/regex/Matcher", "searchPosition", "I", start).await?; + jvm.put_field(this, "java/util/regex/Matcher", "appendPosition", "I", 0).await?; + jvm.put_field(this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; } - let text: ClassInstanceRef = jvm.get_field(this, "text", "Ljava/lang/CharSequence;").await?; + let text: ClassInstanceRef = jvm.get_field(this, "java/util/regex/Matcher", "text", "Ljava/lang/CharSequence;").await?; let snapshot: ClassInstanceRef = jvm .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ()) .await?; @@ -591,17 +618,21 @@ impl Matcher { if let MatchMode::Find { start, .. } = mode && start as usize > utf16.len() { - let mut groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let mut groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(this, "searchPosition", "I", -1).await?; - jvm.put_field(this, "hasMatch", "Z", false).await?; + jvm.put_field(this, "java/util/regex/Matcher", "searchPosition", "I", -1).await?; + jvm.put_field(this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; return Ok(false); } - let pattern: ClassInstanceRef = jvm.get_field(this, "parentPattern", "Ljava/util/regex/Pattern;").await?; - let source: ClassInstanceRef = jvm.get_field(&pattern, "pattern", "Ljava/lang/String;").await?; - let flags: i32 = jvm.get_field(&pattern, "flags", "I").await?; + let pattern: ClassInstanceRef = jvm + .get_field(this, "java/util/regex/Matcher", "parentPattern", "Ljava/util/regex/Pattern;") + .await?; + let source: ClassInstanceRef = jvm + .get_field(&pattern, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;") + .await?; + let flags: i32 = jvm.get_field(&pattern, "java/util/regex/Pattern", "flags", "I").await?; let source_text = JavaLangString::to_rust_string(jvm, &source).await?; let regex = Pattern::build_regex(jvm, &source_text, &source, flags, matches!(mode, MatchMode::Full)).await?; @@ -613,12 +644,18 @@ impl Matcher { MatchMode::Find { start, .. } => regex.captures_at(&rust, Self::utf16_to_byte(&rust, start as usize)), }; let Some(captures) = captures else { - let mut groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let mut groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; let length = jvm.array_length(&groups).await?; jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?; - jvm.put_field(this, "searchPosition", "I", if matches!(mode, MatchMode::Find { .. }) { -1 } else { 0 }) - .await?; - jvm.put_field(this, "hasMatch", "Z", false).await?; + jvm.put_field( + this, + "java/util/regex/Matcher", + "searchPosition", + "I", + if matches!(mode, MatchMode::Find { .. }) { -1 } else { 0 }, + ) + .await?; + jvm.put_field(this, "java/util/regex/Matcher", "hasMatch", "Z", false).await?; return Ok(false); }; @@ -636,7 +673,7 @@ impl Matcher { } }) .collect::>(); - let mut groups: ClassInstanceRef> = jvm.get_field(this, "groups", "[I").await?; + let mut groups: ClassInstanceRef> = jvm.get_field(this, "java/util/regex/Matcher", "groups", "[I").await?; jvm.store_array(&mut groups, 0, ranges).await?; let end = Self::byte_to_utf16(&rust, byte_range.1) as i32; @@ -645,8 +682,9 @@ impl Matcher { } else { end }; - jvm.put_field(this, "searchPosition", "I", search_position).await?; - jvm.put_field(this, "hasMatch", "Z", true).await?; + jvm.put_field(this, "java/util/regex/Matcher", "searchPosition", "I", search_position) + .await?; + jvm.put_field(this, "java/util/regex/Matcher", "hasMatch", "Z", true).await?; Ok(true) } diff --git a/rustjava-runtime/src/classes/java/util/regex/pattern.rs b/rustjava-runtime/src/classes/java/util/regex/pattern.rs index c489600c..53bb490f 100644 --- a/rustjava-runtime/src/classes/java/util/regex/pattern.rs +++ b/rustjava-runtime/src/classes/java/util/regex/pattern.rs @@ -122,8 +122,9 @@ impl Pattern { tracing::debug!("java.util.regex.Pattern::({this:?}, {pattern:?}, {flags})"); let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await?; - jvm.put_field(&mut this, "flags", "I", flags).await + jvm.put_field(&mut this, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;", pattern) + .await?; + jvm.put_field(&mut this, "java/util/regex/Pattern", "flags", "I", flags).await } async fn compile(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef) -> Result> { @@ -160,13 +161,13 @@ impl Pattern { async fn pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.Pattern::pattern({this:?})"); - jvm.get_field(&this, "pattern", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;").await } async fn flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.regex.Pattern::flags({this:?})"); - jvm.get_field(&this, "flags", "I").await + jvm.get_field(&this, "java/util/regex/Pattern", "flags", "I").await } async fn matcher( diff --git a/rustjava-runtime/src/classes/java/util/regex/pattern_syntax_exception.rs b/rustjava-runtime/src/classes/java/util/regex/pattern_syntax_exception.rs index 780db02d..6576ebef 100644 --- a/rustjava-runtime/src/classes/java/util/regex/pattern_syntax_exception.rs +++ b/rustjava-runtime/src/classes/java/util/regex/pattern_syntax_exception.rs @@ -69,35 +69,56 @@ impl PatternSyntaxException { let _: () = jvm .invoke_special(&this, "java/lang/IllegalArgumentException", "", "()V", ()) .await?; - jvm.put_field(&mut this, "desc", "Ljava/lang/String;", description).await?; - jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await?; - jvm.put_field(&mut this, "index", "I", index).await + jvm.put_field( + &mut this, + "java/util/regex/PatternSyntaxException", + "desc", + "Ljava/lang/String;", + description, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/regex/PatternSyntaxException", + "pattern", + "Ljava/lang/String;", + pattern, + ) + .await?; + jvm.put_field(&mut this, "java/util/regex/PatternSyntaxException", "index", "I", index) + .await } async fn get_description(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.PatternSyntaxException::getDescription({this:?})"); - jvm.get_field(&this, "desc", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/regex/PatternSyntaxException", "desc", "Ljava/lang/String;") + .await } async fn get_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.PatternSyntaxException::getPattern({this:?})"); - jvm.get_field(&this, "pattern", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/regex/PatternSyntaxException", "pattern", "Ljava/lang/String;") + .await } async fn get_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.regex.PatternSyntaxException::getIndex({this:?})"); - jvm.get_field(&this, "index", "I").await + jvm.get_field(&this, "java/util/regex/PatternSyntaxException", "index", "I").await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.regex.PatternSyntaxException::getMessage({this:?})"); - let description: ClassInstanceRef = jvm.get_field(&this, "desc", "Ljava/lang/String;").await?; - let pattern: ClassInstanceRef = jvm.get_field(&this, "pattern", "Ljava/lang/String;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let description: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/PatternSyntaxException", "desc", "Ljava/lang/String;") + .await?; + let pattern: ClassInstanceRef = jvm + .get_field(&this, "java/util/regex/PatternSyntaxException", "pattern", "Ljava/lang/String;") + .await?; + let index: i32 = jvm.get_field(&this, "java/util/regex/PatternSyntaxException", "index", "I").await?; let line_separator: ClassInstanceRef = jvm .get_static_field("java/util/regex/PatternSyntaxException", "nl", "Ljava/lang/String;") .await?; diff --git a/rustjava-runtime/src/classes/java/util/simple_time_zone.rs b/rustjava-runtime/src/classes/java/util/simple_time_zone.rs index 32759a1c..69241ebd 100644 --- a/rustjava-runtime/src/classes/java/util/simple_time_zone.rs +++ b/rustjava-runtime/src/classes/java/util/simple_time_zone.rs @@ -53,8 +53,8 @@ impl SimpleTimeZone { } let _: () = jvm.invoke_special(&this, "java/util/TimeZone", "", "()V", ()).await?; - jvm.put_field(&mut this, "rawOffset", "I", raw_offset).await?; - jvm.put_field(&mut this, "ID", "Ljava/lang/String;", id).await + jvm.put_field(&mut this, "java/util/SimpleTimeZone", "rawOffset", "I", raw_offset).await?; + jvm.put_field(&mut this, "java/util/SimpleTimeZone", "ID", "Ljava/lang/String;", id).await } #[allow(clippy::too_many_arguments)] @@ -85,16 +85,16 @@ impl SimpleTimeZone { return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid date fields").await); } - jvm.get_field(&this, "rawOffset", "I").await + jvm.get_field(&this, "java/util/SimpleTimeZone", "rawOffset", "I").await } async fn get_raw_offset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "rawOffset", "I").await + jvm.get_field(&this, "java/util/SimpleTimeZone", "rawOffset", "I").await } async fn set_raw_offset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, offset: i32) -> Result<()> { tracing::debug!("java.util.SimpleTimeZone::setRawOffset({this:?}, {offset:?})"); - jvm.put_field(&mut this, "rawOffset", "I", offset).await + jvm.put_field(&mut this, "java/util/SimpleTimeZone", "rawOffset", "I", offset).await } async fn use_daylight_time(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef) -> Result { diff --git a/rustjava-runtime/src/classes/java/util/string_tokenizer.rs b/rustjava-runtime/src/classes/java/util/string_tokenizer.rs index 0308d55b..4e2170ba 100644 --- a/rustjava-runtime/src/classes/java/util/string_tokenizer.rs +++ b/rustjava-runtime/src/classes/java/util/string_tokenizer.rs @@ -104,21 +104,27 @@ impl StringTokenizer { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let max_position: i32 = jvm.invoke_virtual(&string, "java/lang/String", "length", "()I", ()).await?; - jvm.put_field(&mut this, "str", "Ljava/lang/String;", string).await?; - jvm.put_field(&mut this, "delimiters", "Ljava/lang/String;", delimiters).await?; - jvm.put_field(&mut this, "currentPosition", "I", 0).await?; - jvm.put_field(&mut this, "maxPosition", "I", max_position).await?; - jvm.put_field(&mut this, "returnDelimiters", "Z", return_delimiters).await + jvm.put_field(&mut this, "java/util/StringTokenizer", "str", "Ljava/lang/String;", string) + .await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters) + .await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", 0).await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "maxPosition", "I", max_position) + .await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "returnDelimiters", "Z", return_delimiters) + .await } async fn has_more_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.StringTokenizer::hasMoreTokens({this:?})"); - let string: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; - let delimiters: ClassInstanceRef = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?; - let position: i32 = jvm.get_field(&this, "currentPosition", "I").await?; - let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?; - let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?; + let string: ClassInstanceRef = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?; + let delimiters: ClassInstanceRef = jvm + .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;") + .await?; + let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?; + let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?; + let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?; Ok( Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters) .await? @@ -129,11 +135,13 @@ impl StringTokenizer { async fn next_token(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.StringTokenizer::nextToken({this:?})"); - let string: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; - let delimiters: ClassInstanceRef = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?; - let position: i32 = jvm.get_field(&this, "currentPosition", "I").await?; - let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?; - let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?; + let string: ClassInstanceRef = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?; + let delimiters: ClassInstanceRef = jvm + .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;") + .await?; + let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?; + let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?; + let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?; let Some((start, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await? else { return Err(jvm.exception("java/util/NoSuchElementException", "StringTokenizer exhausted").await); @@ -148,7 +156,8 @@ impl StringTokenizer { (start as i32, end as i32), ) .await?; - jvm.put_field(&mut this, "currentPosition", "I", end as i32).await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", end as i32) + .await?; Ok(token) } @@ -160,7 +169,8 @@ impl StringTokenizer { ) -> Result> { tracing::debug!("java.util.StringTokenizer::nextToken({this:?}, {delimiters:?})"); - jvm.put_field(&mut this, "delimiters", "Ljava/lang/String;", delimiters).await?; + jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters) + .await?; jvm.invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ()) .await } @@ -168,11 +178,13 @@ impl StringTokenizer { async fn count_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.StringTokenizer::countTokens({this:?})"); - let string: ClassInstanceRef = jvm.get_field(&this, "str", "Ljava/lang/String;").await?; - let delimiters: ClassInstanceRef = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?; - let mut position: i32 = jvm.get_field(&this, "currentPosition", "I").await?; - let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?; - let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?; + let string: ClassInstanceRef = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?; + let delimiters: ClassInstanceRef = jvm + .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;") + .await?; + let mut position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?; + let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?; + let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?; let mut count = 0; while let Some((_, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await? { count += 1; diff --git a/rustjava-runtime/src/classes/java/util/time_zone.rs b/rustjava-runtime/src/classes/java/util/time_zone.rs index 91daa5d7..cc1fb6a5 100644 --- a/rustjava-runtime/src/classes/java/util/time_zone.rs +++ b/rustjava-runtime/src/classes/java/util/time_zone.rs @@ -74,7 +74,7 @@ impl TimeZone { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let id = JavaLangString::from_rust_string(jvm, "GMT").await?; - jvm.put_field(&mut this, "ID", "Ljava/lang/String;", id).await + jvm.put_field(&mut this, "java/util/TimeZone", "ID", "Ljava/lang/String;", id).await } async fn get_time_zone(jvm: &Jvm, _: &mut RuntimeContext, id: ClassInstanceRef) -> Result> { @@ -143,7 +143,7 @@ impl TimeZone { } async fn get_id(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "ID", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/TimeZone", "ID", "Ljava/lang/String;").await } async fn set_id(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, id: ClassInstanceRef) -> Result<()> { @@ -152,7 +152,7 @@ impl TimeZone { if id.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "ID").await); } - jvm.put_field(&mut this, "ID", "Ljava/lang/String;", id).await + jvm.put_field(&mut this, "java/util/TimeZone", "ID", "Ljava/lang/String;", id).await } async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { diff --git a/rustjava-runtime/src/classes/java/util/timer.rs b/rustjava-runtime/src/classes/java/util/timer.rs index d1efe35c..dcbf3a68 100644 --- a/rustjava-runtime/src/classes/java/util/timer.rs +++ b/rustjava-runtime/src/classes/java/util/timer.rs @@ -64,8 +64,14 @@ impl Timer { let timer_thread = jvm .new_class("java/util/Timer$TimerThread", "(Ljava/util/Timer$TaskQueue;)V", (queue,)) .await?; - jvm.put_field(&mut this, "thread", "Ljava/util/Timer$TimerThread;", timer_thread.clone()) - .await?; + jvm.put_field( + &mut this, + "java/util/Timer", + "thread", + "Ljava/util/Timer$TimerThread;", + timer_thread.clone(), + ) + .await?; let _: () = jvm .invoke_virtual(&timer_thread, "java/util/Timer$TimerThread", "start", "()V", ()) .await?; @@ -220,26 +226,33 @@ impl Timer { } } - let thread: ClassInstanceRef = jvm.get_field(&this, "thread", "Ljava/util/Timer$TimerThread;").await?; - let mut queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; - let lock: ClassInstanceRef = jvm.get_field(&task, "lock", "Ljava/lang/Object;").await?; + let thread: ClassInstanceRef = jvm.get_field(&this, "java/util/Timer", "thread", "Ljava/util/Timer$TimerThread;").await?; + let mut queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; + let lock: ClassInstanceRef = + jvm.get_field(&task, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?; jvm.monitor_enter(&queue).await?; let schedule_result = async { - if !jvm.get_field::(&thread, "newTasksMayBeScheduled", "Z").await? { + if !jvm + .get_field::(&thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z") + .await? + { return Err(jvm.exception("java/lang/IllegalStateException", "timer already cancelled").await); } jvm.monitor_enter(&lock).await?; let task_result = async { - if jvm.get_field::(&task, "state", "I").await? != TimerTask::VIRGIN { + if jvm.get_field::(&task, "java/util/TimerTask", "state", "I").await? != TimerTask::VIRGIN { return Err(jvm .exception("java/lang/IllegalStateException", "task already scheduled or cancelled") .await); } - jvm.put_field(&mut task, "nextExecutionTime", "J", time).await?; - jvm.put_field(&mut task, "period", "J", period).await?; - jvm.put_field(&mut task, "state", "I", TimerTask::SCHEDULED).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "nextExecutionTime", "J", time).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "period", "J", period).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::SCHEDULED) + .await?; TimerTaskQueue::add(jvm, &mut queue, task.clone()).await } .await; @@ -273,11 +286,14 @@ impl Timer { async fn cancel(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Timer::cancel({this:?})"); - let mut thread: ClassInstanceRef = jvm.get_field(&this, "thread", "Ljava/util/Timer$TimerThread;").await?; - let mut queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; + let mut thread: ClassInstanceRef = jvm.get_field(&this, "java/util/Timer", "thread", "Ljava/util/Timer$TimerThread;").await?; + let mut queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; jvm.monitor_enter(&queue).await?; let cancel_result = async { - jvm.put_field(&mut thread, "newTasksMayBeScheduled", "Z", false).await?; + jvm.put_field(&mut thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", false) + .await?; TimerTaskQueue::clear(jvm, &mut queue).await?; jvm.object_notify(&queue, usize::MAX).await } diff --git a/rustjava-runtime/src/classes/java/util/timer_task.rs b/rustjava-runtime/src/classes/java/util/timer_task.rs index bcf1c844..5fcdccf3 100644 --- a/rustjava-runtime/src/classes/java/util/timer_task.rs +++ b/rustjava-runtime/src/classes/java/util/timer_task.rs @@ -42,8 +42,9 @@ impl TimerTask { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let lock = jvm.new_class("java/lang/Object", "()V", ()).await?; - jvm.put_field(&mut this, "lock", "Ljava/lang/Object;", lock).await?; - jvm.put_field(&mut this, "state", "I", Self::VIRGIN).await?; + jvm.put_field(&mut this, "java/util/TimerTask", "lock", "Ljava/lang/Object;", lock) + .await?; + jvm.put_field(&mut this, "java/util/TimerTask", "state", "I", Self::VIRGIN).await?; Ok(()) } @@ -51,11 +52,11 @@ impl TimerTask { async fn cancel(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { tracing::debug!("java.util.TimerTask::cancel({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?; jvm.monitor_enter(&lock).await?; let result = async { - let state: i32 = jvm.get_field(&this, "state", "I").await?; - jvm.put_field(&mut this, "state", "I", Self::CANCELLED).await?; + let state: i32 = jvm.get_field(&this, "java/util/TimerTask", "state", "I").await?; + jvm.put_field(&mut this, "java/util/TimerTask", "state", "I", Self::CANCELLED).await?; Ok(state == Self::SCHEDULED) } .await; @@ -75,9 +76,9 @@ impl TimerTask { async fn scheduled_execution_time(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.TimerTask::scheduledExecutionTime({this:?})"); - let lock: ClassInstanceRef = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&this, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?; jvm.monitor_enter(&lock).await?; - let result = jvm.get_field(&this, "lastScheduledExecutionTime", "J").await; + let result = jvm.get_field(&this, "java/util/TimerTask", "lastScheduledExecutionTime", "J").await; let exit_result = jvm.monitor_exit(&lock).await; match result { Ok(value) => { diff --git a/rustjava-runtime/src/classes/java/util/timer_task_queue.rs b/rustjava-runtime/src/classes/java/util/timer_task_queue.rs index a4fcd7fd..6019cf99 100644 --- a/rustjava-runtime/src/classes/java/util/timer_task_queue.rs +++ b/rustjava-runtime/src/classes/java/util/timer_task_queue.rs @@ -29,28 +29,32 @@ impl TimerTaskQueue { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; let queue = jvm.instantiate_array("Ljava/util/TimerTask;", 128).await?; - jvm.put_field(&mut this, "queue", "[Ljava/util/TimerTask;", queue).await?; + jvm.put_field(&mut this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;", queue) + .await?; Ok(()) } pub(crate) async fn add(jvm: &Jvm, this: &mut ClassInstanceRef, task: ClassInstanceRef) -> Result { - let size: i32 = jvm.get_field(this, "size", "I").await?; - let mut queue: ClassInstanceRef> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?; + let size: i32 = jvm.get_field(this, "java/util/Timer$TaskQueue", "size", "I").await?; + let mut queue: ClassInstanceRef> = jvm + .get_field(this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; if size as usize + 1 == jvm.array_length(&queue).await? { let old_length = jvm.array_length(&queue).await?; let mut expanded: ClassInstanceRef> = jvm.instantiate_array("Ljava/util/TimerTask;", old_length * 2).await?.into(); let tasks: Vec> = jvm.load_array(&queue, 0, size as usize + 1).await?; jvm.store_array(&mut expanded, 0, tasks).await?; queue = expanded; - jvm.put_field(this, "queue", "[Ljava/util/TimerTask;", queue.clone()).await?; + jvm.put_field(this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;", queue.clone()) + .await?; } let mut child = size as usize + 1; while child > 1 { let parent = child / 2; let parent_task: ClassInstanceRef = jvm.load_array(&queue, parent, 1).await?.remove(0); - let parent_time: i64 = jvm.get_field(&parent_task, "nextExecutionTime", "J").await?; - let task_time: i64 = jvm.get_field(&task, "nextExecutionTime", "J").await?; + let parent_time: i64 = jvm.get_field(&parent_task, "java/util/TimerTask", "nextExecutionTime", "J").await?; + let task_time: i64 = jvm.get_field(&task, "java/util/TimerTask", "nextExecutionTime", "J").await?; if parent_time <= task_time { break; } @@ -58,35 +62,37 @@ impl TimerTaskQueue { child = parent; } jvm.store_array(&mut queue, child, core::iter::once(task)).await?; - jvm.put_field(this, "size", "I", size + 1).await?; + jvm.put_field(this, "java/util/Timer$TaskQueue", "size", "I", size + 1).await?; Ok(child == 1) } pub(crate) async fn remove_min(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/Timer$TaskQueue", "size", "I").await?; if size == 0 { return Ok(()); } - let mut queue: ClassInstanceRef> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?; + let mut queue: ClassInstanceRef> = jvm + .get_field(this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let last: ClassInstanceRef = jvm.load_array(&queue, size as usize, 1).await?.remove(0); let null: ClassInstanceRef = None.into(); jvm.store_array(&mut queue, size as usize, core::iter::once(null)).await?; let new_size = size - 1; - jvm.put_field(this, "size", "I", new_size).await?; + jvm.put_field(this, "java/util/Timer$TaskQueue", "size", "I", new_size).await?; if new_size == 0 { return Ok(()); } - let last_time: i64 = jvm.get_field(&last, "nextExecutionTime", "J").await?; + let last_time: i64 = jvm.get_field(&last, "java/util/TimerTask", "nextExecutionTime", "J").await?; let mut parent = 1usize; while parent * 2 <= new_size as usize { let mut child = parent * 2; let mut child_task: ClassInstanceRef = jvm.load_array(&queue, child, 1).await?.remove(0); - let mut child_time: i64 = jvm.get_field(&child_task, "nextExecutionTime", "J").await?; + let mut child_time: i64 = jvm.get_field(&child_task, "java/util/TimerTask", "nextExecutionTime", "J").await?; if child < new_size as usize { let right: ClassInstanceRef = jvm.load_array(&queue, child + 1, 1).await?.remove(0); - let right_time: i64 = jvm.get_field(&right, "nextExecutionTime", "J").await?; + let right_time: i64 = jvm.get_field(&right, "java/util/TimerTask", "nextExecutionTime", "J").await?; if right_time < child_time { child += 1; child_task = right; @@ -103,19 +109,22 @@ impl TimerTaskQueue { } pub(crate) async fn reschedule_min(jvm: &Jvm, this: &mut ClassInstanceRef, new_time: i64) -> Result<()> { - let mut queue: ClassInstanceRef> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?; + let mut queue: ClassInstanceRef> = jvm + .get_field(this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let mut task: ClassInstanceRef = jvm.load_array(&queue, 1, 1).await?.remove(0); - jvm.put_field(&mut task, "nextExecutionTime", "J", new_time).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "nextExecutionTime", "J", new_time) + .await?; - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/Timer$TaskQueue", "size", "I").await?; let mut parent = 1usize; while parent * 2 <= size as usize { let mut child = parent * 2; let mut child_task: ClassInstanceRef = jvm.load_array(&queue, child, 1).await?.remove(0); - let mut child_time: i64 = jvm.get_field(&child_task, "nextExecutionTime", "J").await?; + let mut child_time: i64 = jvm.get_field(&child_task, "java/util/TimerTask", "nextExecutionTime", "J").await?; if child < size as usize { let right: ClassInstanceRef = jvm.load_array(&queue, child + 1, 1).await?.remove(0); - let right_time: i64 = jvm.get_field(&right, "nextExecutionTime", "J").await?; + let right_time: i64 = jvm.get_field(&right, "java/util/TimerTask", "nextExecutionTime", "J").await?; if right_time < child_time { child += 1; child_task = right; @@ -132,12 +141,14 @@ impl TimerTaskQueue { } pub(crate) async fn clear(jvm: &Jvm, this: &mut ClassInstanceRef) -> Result<()> { - let size: i32 = jvm.get_field(this, "size", "I").await?; + let size: i32 = jvm.get_field(this, "java/util/Timer$TaskQueue", "size", "I").await?; if size > 0 { - let mut queue: ClassInstanceRef> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?; + let mut queue: ClassInstanceRef> = jvm + .get_field(this, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let nulls = core::iter::repeat_with(|| ClassInstanceRef::::from(None)).take(size as usize); jvm.store_array(&mut queue, 1, nulls).await?; - jvm.put_field(this, "size", "I", 0i32).await?; + jvm.put_field(this, "java/util/Timer$TaskQueue", "size", "I", 0i32).await?; } Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/timer_thread.rs b/rustjava-runtime/src/classes/java/util/timer_thread.rs index 20cb134e..f27862af 100644 --- a/rustjava-runtime/src/classes/java/util/timer_thread.rs +++ b/rustjava-runtime/src/classes/java/util/timer_thread.rs @@ -40,8 +40,10 @@ impl TimerThread { tracing::debug!("java.util.Timer$TimerThread::({this:?})"); let _: () = jvm.invoke_special(&this, "java/lang/Thread", "", "()V", ()).await?; - jvm.put_field(&mut this, "queue", "Ljava/util/Timer$TaskQueue;", queue).await?; - jvm.put_field(&mut this, "newTasksMayBeScheduled", "Z", true).await?; + jvm.put_field(&mut this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;", queue) + .await?; + jvm.put_field(&mut this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", true) + .await?; Ok(()) } @@ -50,10 +52,13 @@ impl TimerThread { let result = Self::main_loop(jvm, context, &this).await; let mut thread = this; - let mut queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; + let mut queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; jvm.monitor_enter(&queue).await?; let cleanup_result = async { - jvm.put_field(&mut thread, "newTasksMayBeScheduled", "Z", false).await?; + jvm.put_field(&mut thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", false) + .await?; TimerTaskQueue::clear(jvm, &mut queue).await?; jvm.object_notify(&queue, usize::MAX).await } @@ -77,15 +82,20 @@ impl TimerThread { } async fn main_loop(jvm: &Jvm, context: &mut RuntimeContext, this: &ClassInstanceRef) -> Result<()> { - let mut queue: ClassInstanceRef = jvm.get_field(this, "queue", "Ljava/util/Timer$TaskQueue;").await?; + let mut queue: ClassInstanceRef = jvm + .get_field(this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; loop { jvm.monitor_enter(&queue).await?; let action_result = async { loop { - let size: i32 = jvm.get_field(&queue, "size", "I").await?; + let size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?; if size == 0 { - if !jvm.get_field::(this, "newTasksMayBeScheduled", "Z").await? { + if !jvm + .get_field::(this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z") + .await? + { return Ok(WorkerAction::Stop); } let wait_result: Result<()> = jvm.invoke_virtual(&queue, "java/lang/Object", "wait", "()V", ()).await; @@ -101,28 +111,32 @@ impl TimerThread { continue; } - let heap: ClassInstanceRef> = jvm.get_field(&queue, "queue", "[Ljava/util/TimerTask;").await?; + let heap: ClassInstanceRef> = jvm + .get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let mut task: ClassInstanceRef = jvm.load_array(&heap, 1, 1).await?.remove(0); - let lock: ClassInstanceRef = jvm.get_field(&task, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = + jvm.get_field(&task, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?; jvm.monitor_enter(&lock).await?; let task_result = async { - let state: i32 = jvm.get_field(&task, "state", "I").await?; + let state: i32 = jvm.get_field(&task, "java/util/TimerTask", "state", "I").await?; if state == TimerTask::CANCELLED { TimerTaskQueue::remove_min(jvm, &mut queue).await?; return Ok(WorkerAction::Continue); } let now = context.now() as i64; - let execution_time: i64 = jvm.get_field(&task, "nextExecutionTime", "J").await?; + let execution_time: i64 = jvm.get_field(&task, "java/util/TimerTask", "nextExecutionTime", "J").await?; if execution_time > now { return Ok(WorkerAction::Continue); } - let period: i64 = jvm.get_field(&task, "period", "J").await?; - jvm.put_field(&mut task, "lastScheduledExecutionTime", "J", execution_time).await?; + let period: i64 = jvm.get_field(&task, "java/util/TimerTask", "period", "J").await?; + jvm.put_field(&mut task, "java/util/TimerTask", "lastScheduledExecutionTime", "J", execution_time) + .await?; if period == 0 { TimerTaskQueue::remove_min(jvm, &mut queue).await?; - jvm.put_field(&mut task, "state", "I", TimerTask::EXECUTED).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?; } else { let next_execution_time = if period < 0 { now.checked_sub(period) @@ -133,7 +147,7 @@ impl TimerThread { TimerTaskQueue::reschedule_min(jvm, &mut queue, next_execution_time).await?; } else { TimerTaskQueue::remove_min(jvm, &mut queue).await?; - jvm.put_field(&mut task, "state", "I", TimerTask::EXECUTED).await?; + jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?; } } Ok(WorkerAction::Run(task.clone())) @@ -154,13 +168,15 @@ impl TimerThread { if matches!(action, WorkerAction::Run(_)) { return Ok(action); } - let next_size: i32 = jvm.get_field(&queue, "size", "I").await?; + let next_size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?; if next_size == 0 { continue; } - let next_heap: ClassInstanceRef> = jvm.get_field(&queue, "queue", "[Ljava/util/TimerTask;").await?; + let next_heap: ClassInstanceRef> = jvm + .get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let next_task: ClassInstanceRef = jvm.load_array(&next_heap, 1, 1).await?.remove(0); - let next_execution_time: i64 = jvm.get_field(&next_task, "nextExecutionTime", "J").await?; + let next_execution_time: i64 = jvm.get_field(&next_task, "java/util/TimerTask", "nextExecutionTime", "J").await?; let now = context.now() as i64; if next_execution_time <= now { continue; diff --git a/rustjava-runtime/src/classes/java/util/tree_map.rs b/rustjava-runtime/src/classes/java/util/tree_map.rs index ac5f4f0d..3bbf5ebb 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map.rs @@ -103,7 +103,8 @@ impl TreeMap { comparator: ClassInstanceRef, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "", "()V", ()).await?; - jvm.put_field(&mut this, "comparator", "Ljava/util/Comparator;", comparator).await + jvm.put_field(&mut this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;", comparator) + .await } async fn init_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { @@ -128,7 +129,7 @@ impl TreeMap { } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "java/util/TreeMap", "size", "I").await } async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { @@ -138,7 +139,7 @@ impl TreeMap { async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { let mut entry = Self::first_entry(jvm, &this).await?; while !entry.is_null() { - let current: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let current: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; let equal = if value.is_null() { current.is_null() } else { @@ -158,7 +159,7 @@ impl TreeMap { if entry.is_null() { return Ok(None.into()); } - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await } async fn put( @@ -168,7 +169,7 @@ impl TreeMap { key: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let root: ClassInstanceRef = jvm.get_field(&this, "root", "Ljava/util/TreeMap$Entry;").await?; + let root: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; if root.is_null() { let _ = Self::compare(jvm, &this, &key, &key).await?; let entry: ClassInstanceRef = jvm @@ -179,26 +180,30 @@ impl TreeMap { ) .await? .into(); - jvm.put_field(&mut this, "root", "Ljava/util/TreeMap$Entry;", entry).await?; - jvm.put_field(&mut this, "size", "I", 1).await?; + jvm.put_field(&mut this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", entry) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", 1).await?; return Ok(None.into()); } let mut parent = root; let comparison; loop { - let stored_key: ClassInstanceRef = jvm.get_field(&parent, "key", "Ljava/lang/Object;").await?; + let stored_key: ClassInstanceRef = jvm.get_field(&parent, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; let current_comparison = Self::compare(jvm, &this, &key, &stored_key).await?; if current_comparison == 0 { - let old_value: ClassInstanceRef = jvm.get_field(&parent, "value", "Ljava/lang/Object;").await?; + let old_value: ClassInstanceRef = jvm.get_field(&parent, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; let mut parent = parent; - jvm.put_field(&mut parent, "value", "Ljava/lang/Object;", value).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; return Ok(old_value); } let child: ClassInstanceRef = if current_comparison < 0 { - jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await? } else { - jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await? }; if child.is_null() { comparison = current_comparison; @@ -215,15 +220,23 @@ impl TreeMap { ) .await? .into(); - jvm.put_field(&mut entry, "color", "Z", false).await?; + jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", false).await?; let mut parent = parent; if comparison < 0 { - jvm.put_field(&mut parent, "left", "Ljava/util/TreeMap$Entry;", entry.clone()).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", entry.clone()) + .await?; } else { - jvm.put_field(&mut parent, "right", "Ljava/util/TreeMap$Entry;", entry.clone()).await?; + jvm.put_field( + &mut parent, + "java/util/TreeMap$Entry", + "right", + "Ljava/util/TreeMap$Entry;", + entry.clone(), + ) + .await?; } - let size: i32 = jvm.get_field(&this, "size", "I").await?; - jvm.put_field(&mut this, "size", "I", size + 1).await?; + let size: i32 = jvm.get_field(&this, "java/util/TreeMap", "size", "I").await?; + jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", size + 1).await?; Self::fix_after_insertion(jvm, &mut this, entry).await?; Ok(None.into()) } @@ -248,7 +261,7 @@ impl TreeMap { if entry.is_null() { return Ok(None.into()); } - let old_value: ClassInstanceRef = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?; + let old_value: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; Self::delete_entry(jvm, &mut this, entry).await?; Ok(old_value) } @@ -256,16 +269,17 @@ impl TreeMap { async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { jvm.put_field( &mut this, + "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), ) .await?; - jvm.put_field(&mut this, "size", "I", 0).await + jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", 0).await } async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "comparator", "Ljava/util/Comparator;").await + jvm.get_field(&this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await } async fn first_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -273,7 +287,7 @@ impl TreeMap { if entry.is_null() { return Err(jvm.exception("java/util/NoSuchElementException", "empty TreeMap").await); } - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } async fn last_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -281,7 +295,7 @@ impl TreeMap { if entry.is_null() { return Err(jvm.exception("java/util/NoSuchElementException", "empty TreeMap").await); } - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } async fn sub_map( @@ -434,7 +448,7 @@ impl TreeMap { left: &ClassInstanceRef, right: &ClassInstanceRef, ) -> Result { - let comparator: ClassInstanceRef = jvm.get_field(this, "comparator", "Ljava/util/Comparator;").await?; + let comparator: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await?; if !comparator.is_null() { return jvm .invoke_virtual( @@ -467,7 +481,7 @@ impl TreeMap { this: &ClassInstanceRef, key: &ClassInstanceRef, ) -> Result> { - let comparator: ClassInstanceRef = jvm.get_field(this, "comparator", "Ljava/util/Comparator;").await?; + let comparator: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await?; if comparator.is_null() { if key.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "null key").await); @@ -477,9 +491,9 @@ impl TreeMap { } } - let mut entry: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let mut entry: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; while !entry.is_null() { - let stored_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let stored_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; let comparison: i32 = if comparator.is_null() { jvm.invoke_virtual(key, &key.class_definition().name(), "compareTo", "(Ljava/lang/Object;)I", (stored_key,)) .await? @@ -497,21 +511,25 @@ impl TreeMap { return Ok(entry); } entry = if comparison < 0 { - jvm.get_field(&entry, "left", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await? } else { - jvm.get_field(&entry, "right", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await? }; } Ok(None.into()) } pub(super) async fn first_entry(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let mut entry: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let mut entry: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; if entry.is_null() { return Ok(entry); } loop { - let left: ClassInstanceRef = jvm.get_field(&entry, "left", "Ljava/util/TreeMap$Entry;").await?; + let left: ClassInstanceRef = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if left.is_null() { return Ok(entry); } @@ -520,12 +538,14 @@ impl TreeMap { } pub(super) async fn last_entry(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let mut entry: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let mut entry: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; if entry.is_null() { return Ok(entry); } loop { - let right: ClassInstanceRef = jvm.get_field(&entry, "right", "Ljava/util/TreeMap$Entry;").await?; + let right: ClassInstanceRef = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if right.is_null() { return Ok(entry); } @@ -538,19 +558,23 @@ impl TreeMap { this: &ClassInstanceRef, key: &ClassInstanceRef, ) -> Result> { - let mut entry: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let mut entry: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; let mut candidate: ClassInstanceRef = None.into(); while !entry.is_null() { - let stored_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let stored_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; let comparison = Self::compare(jvm, this, key, &stored_key).await?; if comparison == 0 { return Ok(entry); } if comparison < 0 { candidate = entry.clone(); - entry = jvm.get_field(&entry, "left", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; } else { - entry = jvm.get_field(&entry, "right", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; } } Ok(candidate) @@ -561,15 +585,19 @@ impl TreeMap { this: &ClassInstanceRef, key: &ClassInstanceRef, ) -> Result> { - let mut entry: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let mut entry: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; let mut candidate: ClassInstanceRef = None.into(); while !entry.is_null() { - let stored_key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; + let stored_key: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; if Self::compare(jvm, this, key, &stored_key).await? <= 0 { - entry = jvm.get_field(&entry, "left", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; } else { candidate = entry.clone(); - entry = jvm.get_field(&entry, "right", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; } } Ok(candidate) @@ -579,11 +607,15 @@ impl TreeMap { if entry.is_null() { return Ok(None.into()); } - let right: ClassInstanceRef = jvm.get_field(&entry, "right", "Ljava/util/TreeMap$Entry;").await?; + let right: ClassInstanceRef = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !right.is_null() { let mut candidate = right; loop { - let left: ClassInstanceRef = jvm.get_field(&candidate, "left", "Ljava/util/TreeMap$Entry;").await?; + let left: ClassInstanceRef = jvm + .get_field(&candidate, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if left.is_null() { return Ok(candidate); } @@ -592,169 +624,304 @@ impl TreeMap { } let mut child = entry; - let mut parent: ClassInstanceRef = jvm.get_field(&child, "parent", "Ljava/util/TreeMap$Entry;").await?; + let mut parent: ClassInstanceRef = jvm + .get_field(&child, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; while !parent.is_null() { - let parent_right: ClassInstanceRef = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + let parent_right: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if parent_right.is_null() || child.identity() != parent_right.identity() { break; } child = parent; - parent = jvm.get_field(&child, "parent", "Ljava/util/TreeMap$Entry;").await?; + parent = jvm + .get_field(&child, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; } Ok(parent) } async fn rotate_left(jvm: &Jvm, this: &mut ClassInstanceRef, mut pivot: ClassInstanceRef) -> Result<()> { - let mut right: ClassInstanceRef = jvm.get_field(&pivot, "right", "Ljava/util/TreeMap$Entry;").await?; - let right_left: ClassInstanceRef = jvm.get_field(&right, "left", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut pivot, "right", "Ljava/util/TreeMap$Entry;", right_left.clone()) + let mut right: ClassInstanceRef = jvm + .get_field(&pivot, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") .await?; + let right_left: ClassInstanceRef = jvm + .get_field(&right, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + jvm.put_field( + &mut pivot, + "java/util/TreeMap$Entry", + "right", + "Ljava/util/TreeMap$Entry;", + right_left.clone(), + ) + .await?; if !right_left.is_null() { let mut right_left = right_left; - jvm.put_field(&mut right_left, "parent", "Ljava/util/TreeMap$Entry;", pivot.clone()) - .await?; + jvm.put_field( + &mut right_left, + "java/util/TreeMap$Entry", + "parent", + "Ljava/util/TreeMap$Entry;", + pivot.clone(), + ) + .await?; } - let parent: ClassInstanceRef = jvm.get_field(&pivot, "parent", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut right, "parent", "Ljava/util/TreeMap$Entry;", parent.clone()).await?; + let parent: ClassInstanceRef = jvm + .get_field(&pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + jvm.put_field( + &mut right, + "java/util/TreeMap$Entry", + "parent", + "Ljava/util/TreeMap$Entry;", + parent.clone(), + ) + .await?; if parent.is_null() { - jvm.put_field(this, "root", "Ljava/util/TreeMap$Entry;", right.clone()).await?; + jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", right.clone()) + .await?; } else { - let parent_left: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + let parent_left: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; let mut parent = parent; if !parent_left.is_null() && parent_left.identity() == pivot.identity() { - jvm.put_field(&mut parent, "left", "Ljava/util/TreeMap$Entry;", right.clone()).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", right.clone()) + .await?; } else { - jvm.put_field(&mut parent, "right", "Ljava/util/TreeMap$Entry;", right.clone()).await?; + jvm.put_field( + &mut parent, + "java/util/TreeMap$Entry", + "right", + "Ljava/util/TreeMap$Entry;", + right.clone(), + ) + .await?; } } - jvm.put_field(&mut right, "left", "Ljava/util/TreeMap$Entry;", pivot.clone()).await?; - jvm.put_field(&mut pivot, "parent", "Ljava/util/TreeMap$Entry;", right).await + jvm.put_field(&mut right, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", pivot.clone()) + .await?; + jvm.put_field(&mut pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", right) + .await } async fn rotate_right(jvm: &Jvm, this: &mut ClassInstanceRef, mut pivot: ClassInstanceRef) -> Result<()> { - let mut left: ClassInstanceRef = jvm.get_field(&pivot, "left", "Ljava/util/TreeMap$Entry;").await?; - let left_right: ClassInstanceRef = jvm.get_field(&left, "right", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut pivot, "left", "Ljava/util/TreeMap$Entry;", left_right.clone()).await?; + let mut left: ClassInstanceRef = jvm + .get_field(&pivot, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let left_right: ClassInstanceRef = jvm + .get_field(&left, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; + jvm.put_field( + &mut pivot, + "java/util/TreeMap$Entry", + "left", + "Ljava/util/TreeMap$Entry;", + left_right.clone(), + ) + .await?; if !left_right.is_null() { let mut left_right = left_right; - jvm.put_field(&mut left_right, "parent", "Ljava/util/TreeMap$Entry;", pivot.clone()) - .await?; + jvm.put_field( + &mut left_right, + "java/util/TreeMap$Entry", + "parent", + "Ljava/util/TreeMap$Entry;", + pivot.clone(), + ) + .await?; } - let parent: ClassInstanceRef = jvm.get_field(&pivot, "parent", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut left, "parent", "Ljava/util/TreeMap$Entry;", parent.clone()).await?; + let parent: ClassInstanceRef = jvm + .get_field(&pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + jvm.put_field( + &mut left, + "java/util/TreeMap$Entry", + "parent", + "Ljava/util/TreeMap$Entry;", + parent.clone(), + ) + .await?; if parent.is_null() { - jvm.put_field(this, "root", "Ljava/util/TreeMap$Entry;", left.clone()).await?; + jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", left.clone()) + .await?; } else { - let parent_right: ClassInstanceRef = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + let parent_right: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; let mut parent = parent; if !parent_right.is_null() && parent_right.identity() == pivot.identity() { - jvm.put_field(&mut parent, "right", "Ljava/util/TreeMap$Entry;", left.clone()).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", left.clone()) + .await?; } else { - jvm.put_field(&mut parent, "left", "Ljava/util/TreeMap$Entry;", left.clone()).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", left.clone()) + .await?; } } - jvm.put_field(&mut left, "right", "Ljava/util/TreeMap$Entry;", pivot.clone()).await?; - jvm.put_field(&mut pivot, "parent", "Ljava/util/TreeMap$Entry;", left).await + jvm.put_field(&mut left, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", pivot.clone()) + .await?; + jvm.put_field(&mut pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", left) + .await } async fn fix_after_insertion(jvm: &Jvm, this: &mut ClassInstanceRef, mut entry: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut entry, "color", "Z", false).await?; + jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", false).await?; loop { - let root: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + let root: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; if entry.identity() == root.identity() { break; } - let mut parent: ClassInstanceRef = jvm.get_field(&entry, "parent", "Ljava/util/TreeMap$Entry;").await?; - if parent.is_null() || jvm.get_field::(&parent, "color", "Z").await? { + let mut parent: ClassInstanceRef = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + if parent.is_null() || jvm.get_field::(&parent, "java/util/TreeMap$Entry", "color", "Z").await? { break; } - let mut grand: ClassInstanceRef = jvm.get_field(&parent, "parent", "Ljava/util/TreeMap$Entry;").await?; - let grand_left: ClassInstanceRef = jvm.get_field(&grand, "left", "Ljava/util/TreeMap$Entry;").await?; + let mut grand: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + let grand_left: ClassInstanceRef = jvm + .get_field(&grand, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if !grand_left.is_null() && grand_left.identity() == parent.identity() { - let mut uncle: ClassInstanceRef = jvm.get_field(&grand, "right", "Ljava/util/TreeMap$Entry;").await?; - let uncle_is_red = !uncle.is_null() && !jvm.get_field::(&uncle, "color", "Z").await?; + let mut uncle: ClassInstanceRef = jvm + .get_field(&grand, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; + let uncle_is_red = !uncle.is_null() && !jvm.get_field::(&uncle, "java/util/TreeMap$Entry", "color", "Z").await?; if uncle_is_red { - jvm.put_field(&mut parent, "color", "Z", true).await?; - jvm.put_field(&mut uncle, "color", "Z", true).await?; - jvm.put_field(&mut grand, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut uncle, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?; entry = grand; continue; } - let parent_right: ClassInstanceRef = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + let parent_right: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !parent_right.is_null() && parent_right.identity() == entry.identity() { entry = parent.clone(); Self::rotate_left(jvm, this, entry.clone()).await?; - parent = jvm.get_field(&entry, "parent", "Ljava/util/TreeMap$Entry;").await?; - grand = jvm.get_field(&parent, "parent", "Ljava/util/TreeMap$Entry;").await?; + parent = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + grand = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; } - jvm.put_field(&mut parent, "color", "Z", true).await?; - jvm.put_field(&mut grand, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_right(jvm, this, grand).await?; } else { - let mut uncle: ClassInstanceRef = jvm.get_field(&grand, "left", "Ljava/util/TreeMap$Entry;").await?; - let uncle_is_red = !uncle.is_null() && !jvm.get_field::(&uncle, "color", "Z").await?; + let mut uncle: ClassInstanceRef = jvm + .get_field(&grand, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let uncle_is_red = !uncle.is_null() && !jvm.get_field::(&uncle, "java/util/TreeMap$Entry", "color", "Z").await?; if uncle_is_red { - jvm.put_field(&mut parent, "color", "Z", true).await?; - jvm.put_field(&mut uncle, "color", "Z", true).await?; - jvm.put_field(&mut grand, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut uncle, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?; entry = grand; continue; } - let parent_left: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + let parent_left: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if !parent_left.is_null() && parent_left.identity() == entry.identity() { entry = parent.clone(); Self::rotate_right(jvm, this, entry.clone()).await?; - parent = jvm.get_field(&entry, "parent", "Ljava/util/TreeMap$Entry;").await?; - grand = jvm.get_field(&parent, "parent", "Ljava/util/TreeMap$Entry;").await?; + parent = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + grand = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; } - jvm.put_field(&mut parent, "color", "Z", true).await?; - jvm.put_field(&mut grand, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; + jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_left(jvm, this, grand).await?; } } - let mut root: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut root, "color", "Z", true).await?; + let mut root: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; + jvm.put_field(&mut root, "java/util/TreeMap$Entry", "color", "Z", true).await?; Ok(()) } pub(super) async fn delete_entry(jvm: &Jvm, this: &mut ClassInstanceRef, entry: ClassInstanceRef) -> Result<()> { - let size: i32 = jvm.get_field(this, "size", "I").await?; - jvm.put_field(this, "size", "I", size - 1).await?; + let size: i32 = jvm.get_field(this, "java/util/TreeMap", "size", "I").await?; + jvm.put_field(this, "java/util/TreeMap", "size", "I", size - 1).await?; let mut target = entry; - let left: ClassInstanceRef = jvm.get_field(&target, "left", "Ljava/util/TreeMap$Entry;").await?; - let right: ClassInstanceRef = jvm.get_field(&target, "right", "Ljava/util/TreeMap$Entry;").await?; + let left: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let right: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !left.is_null() && !right.is_null() { let successor = Self::successor(jvm, target.clone()).await?; - let key: ClassInstanceRef = jvm.get_field(&successor, "key", "Ljava/lang/Object;").await?; - let value: ClassInstanceRef = jvm.get_field(&successor, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut target, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut target, "value", "Ljava/lang/Object;", value).await?; + let key: ClassInstanceRef = jvm.get_field(&successor, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm + .get_field(&successor, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;") + .await?; + jvm.put_field(&mut target, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;", key) + .await?; + jvm.put_field(&mut target, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; target = successor; } - let target_left: ClassInstanceRef = jvm.get_field(&target, "left", "Ljava/util/TreeMap$Entry;").await?; - let target_right: ClassInstanceRef = jvm.get_field(&target, "right", "Ljava/util/TreeMap$Entry;").await?; + let target_left: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let target_right: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; let mut replacement = if !target_left.is_null() { target_left } else { target_right }; if !replacement.is_null() { - let parent: ClassInstanceRef = jvm.get_field(&target, "parent", "Ljava/util/TreeMap$Entry;").await?; - jvm.put_field(&mut replacement, "parent", "Ljava/util/TreeMap$Entry;", parent.clone()) + let parent: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") .await?; + jvm.put_field( + &mut replacement, + "java/util/TreeMap$Entry", + "parent", + "Ljava/util/TreeMap$Entry;", + parent.clone(), + ) + .await?; if parent.is_null() { - jvm.put_field(this, "root", "Ljava/util/TreeMap$Entry;", replacement.clone()).await?; + jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", replacement.clone()) + .await?; } else { - let parent_left: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + let parent_left: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; let mut parent = parent; if !parent_left.is_null() && parent_left.identity() == target.identity() { - jvm.put_field(&mut parent, "left", "Ljava/util/TreeMap$Entry;", replacement.clone()) - .await?; + jvm.put_field( + &mut parent, + "java/util/TreeMap$Entry", + "left", + "Ljava/util/TreeMap$Entry;", + replacement.clone(), + ) + .await?; } else { - jvm.put_field(&mut parent, "right", "Ljava/util/TreeMap$Entry;", replacement.clone()) - .await?; + jvm.put_field( + &mut parent, + "java/util/TreeMap$Entry", + "right", + "Ljava/util/TreeMap$Entry;", + replacement.clone(), + ) + .await?; } } jvm.put_field( &mut target, + "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -762,6 +929,7 @@ impl TreeMap { .await?; jvm.put_field( &mut target, + "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -769,31 +937,47 @@ impl TreeMap { .await?; jvm.put_field( &mut target, + "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), ) .await?; - if jvm.get_field::(&target, "color", "Z").await? { + if jvm.get_field::(&target, "java/util/TreeMap$Entry", "color", "Z").await? { Self::fix_after_deletion(jvm, this, replacement).await?; } } else { - let parent: ClassInstanceRef = jvm.get_field(&target, "parent", "Ljava/util/TreeMap$Entry;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; if parent.is_null() { - jvm.put_field(this, "root", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None)) - .await?; + jvm.put_field( + this, + "java/util/TreeMap", + "root", + "Ljava/util/TreeMap$Entry;", + ClassInstanceRef::::from(None), + ) + .await?; } else { - if jvm.get_field::(&target, "color", "Z").await? { + if jvm.get_field::(&target, "java/util/TreeMap$Entry", "color", "Z").await? { Self::fix_after_deletion(jvm, this, target.clone()).await?; } - let parent: ClassInstanceRef = jvm.get_field(&target, "parent", "Ljava/util/TreeMap$Entry;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; if !parent.is_null() { - let parent_left: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; - let parent_right: ClassInstanceRef = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + let parent_left: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let parent_right: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; let mut parent = parent; if !parent_left.is_null() && parent_left.identity() == target.identity() { jvm.put_field( &mut parent, + "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -802,6 +986,7 @@ impl TreeMap { } else if !parent_right.is_null() && parent_right.identity() == target.identity() { jvm.put_field( &mut parent, + "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -810,6 +995,7 @@ impl TreeMap { } jvm.put_field( &mut target, + "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -823,122 +1009,146 @@ impl TreeMap { async fn fix_after_deletion(jvm: &Jvm, this: &mut ClassInstanceRef, mut entry: ClassInstanceRef) -> Result<()> { loop { - let root: ClassInstanceRef = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; - if entry.identity() == root.identity() || !jvm.get_field::(&entry, "color", "Z").await? { + let root: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; + if entry.identity() == root.identity() || !jvm.get_field::(&entry, "java/util/TreeMap$Entry", "color", "Z").await? { break; } - let parent: ClassInstanceRef = jvm.get_field(&entry, "parent", "Ljava/util/TreeMap$Entry;").await?; - let parent_left: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; + let parent_left: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if !parent_left.is_null() && parent_left.identity() == entry.identity() { - let mut sibling: ClassInstanceRef = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; - if !sibling.is_null() && !jvm.get_field::(&sibling, "color", "Z").await? { - jvm.put_field(&mut sibling, "color", "Z", true).await?; + let mut sibling: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; + if !sibling.is_null() && !jvm.get_field::(&sibling, "java/util/TreeMap$Entry", "color", "Z").await? { + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", true).await?; let mut parent = parent.clone(); - jvm.put_field(&mut parent, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_left(jvm, this, parent.clone()).await?; - sibling = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + sibling = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; } let sibling_left: ClassInstanceRef = if sibling.is_null() { None.into() } else { - jvm.get_field(&sibling, "left", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await? }; let sibling_right: ClassInstanceRef = if sibling.is_null() { None.into() } else { - jvm.get_field(&sibling, "right", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await? }; - let left_black = sibling_left.is_null() || jvm.get_field::(&sibling_left, "color", "Z").await?; - let right_black = sibling_right.is_null() || jvm.get_field::(&sibling_right, "color", "Z").await?; + let left_black = sibling_left.is_null() || jvm.get_field::(&sibling_left, "java/util/TreeMap$Entry", "color", "Z").await?; + let right_black = sibling_right.is_null() || jvm.get_field::(&sibling_right, "java/util/TreeMap$Entry", "color", "Z").await?; if left_black && right_black { if !sibling.is_null() { - jvm.put_field(&mut sibling, "color", "Z", false).await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?; } entry = parent; } else { if right_black { if !sibling_left.is_null() { let mut sibling_left = sibling_left; - jvm.put_field(&mut sibling_left, "color", "Z", true).await?; + jvm.put_field(&mut sibling_left, "java/util/TreeMap$Entry", "color", "Z", true).await?; } if !sibling.is_null() { - jvm.put_field(&mut sibling, "color", "Z", false).await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_right(jvm, this, sibling.clone()).await?; } - sibling = jvm.get_field(&parent, "right", "Ljava/util/TreeMap$Entry;").await?; + sibling = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; } if !sibling.is_null() { - let parent_color: bool = jvm.get_field(&parent, "color", "Z").await?; - jvm.put_field(&mut sibling, "color", "Z", parent_color).await?; + let parent_color: bool = jvm.get_field(&parent, "java/util/TreeMap$Entry", "color", "Z").await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", parent_color).await?; } let mut parent = parent; - jvm.put_field(&mut parent, "color", "Z", true).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; if !sibling.is_null() { - let mut sibling_right: ClassInstanceRef = jvm.get_field(&sibling, "right", "Ljava/util/TreeMap$Entry;").await?; + let mut sibling_right: ClassInstanceRef = jvm + .get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !sibling_right.is_null() { - jvm.put_field(&mut sibling_right, "color", "Z", true).await?; + jvm.put_field(&mut sibling_right, "java/util/TreeMap$Entry", "color", "Z", true).await?; } } Self::rotate_left(jvm, this, parent).await?; - entry = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; } } else { - let mut sibling: ClassInstanceRef = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; - if !sibling.is_null() && !jvm.get_field::(&sibling, "color", "Z").await? { - jvm.put_field(&mut sibling, "color", "Z", true).await?; + let mut sibling: ClassInstanceRef = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + if !sibling.is_null() && !jvm.get_field::(&sibling, "java/util/TreeMap$Entry", "color", "Z").await? { + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", true).await?; let mut parent = parent.clone(); - jvm.put_field(&mut parent, "color", "Z", false).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_right(jvm, this, parent.clone()).await?; - sibling = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + sibling = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; } let sibling_left: ClassInstanceRef = if sibling.is_null() { None.into() } else { - jvm.get_field(&sibling, "left", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await? }; let sibling_right: ClassInstanceRef = if sibling.is_null() { None.into() } else { - jvm.get_field(&sibling, "right", "Ljava/util/TreeMap$Entry;").await? + jvm.get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await? }; - let left_black = sibling_left.is_null() || jvm.get_field::(&sibling_left, "color", "Z").await?; - let right_black = sibling_right.is_null() || jvm.get_field::(&sibling_right, "color", "Z").await?; + let left_black = sibling_left.is_null() || jvm.get_field::(&sibling_left, "java/util/TreeMap$Entry", "color", "Z").await?; + let right_black = sibling_right.is_null() || jvm.get_field::(&sibling_right, "java/util/TreeMap$Entry", "color", "Z").await?; if left_black && right_black { if !sibling.is_null() { - jvm.put_field(&mut sibling, "color", "Z", false).await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?; } entry = parent; } else { if left_black { if !sibling_right.is_null() { let mut sibling_right = sibling_right; - jvm.put_field(&mut sibling_right, "color", "Z", true).await?; + jvm.put_field(&mut sibling_right, "java/util/TreeMap$Entry", "color", "Z", true).await?; } if !sibling.is_null() { - jvm.put_field(&mut sibling, "color", "Z", false).await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?; Self::rotate_left(jvm, this, sibling.clone()).await?; } - sibling = jvm.get_field(&parent, "left", "Ljava/util/TreeMap$Entry;").await?; + sibling = jvm + .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; } if !sibling.is_null() { - let parent_color: bool = jvm.get_field(&parent, "color", "Z").await?; - jvm.put_field(&mut sibling, "color", "Z", parent_color).await?; + let parent_color: bool = jvm.get_field(&parent, "java/util/TreeMap$Entry", "color", "Z").await?; + jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", parent_color).await?; } let mut parent = parent; - jvm.put_field(&mut parent, "color", "Z", true).await?; + jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?; if !sibling.is_null() { - let mut sibling_left: ClassInstanceRef = jvm.get_field(&sibling, "left", "Ljava/util/TreeMap$Entry;").await?; + let mut sibling_left: ClassInstanceRef = jvm + .get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; if !sibling_left.is_null() { - jvm.put_field(&mut sibling_left, "color", "Z", true).await?; + jvm.put_field(&mut sibling_left, "java/util/TreeMap$Entry", "color", "Z", true).await?; } } Self::rotate_right(jvm, this, parent).await?; - entry = jvm.get_field(this, "root", "Ljava/util/TreeMap$Entry;").await?; + entry = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; } } } if !entry.is_null() { - jvm.put_field(&mut entry, "color", "Z", true).await?; + jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", true).await?; } Ok(()) } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_entry.rs b/rustjava-runtime/src/classes/java/util/tree_map_entry.rs index 0b70fb7c..88dae726 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_entry.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_entry.rs @@ -54,18 +54,21 @@ impl TreeMapEntry { parent: ClassInstanceRef, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "parent", "Ljava/util/TreeMap$Entry;", parent).await?; - jvm.put_field(&mut this, "color", "Z", true).await + jvm.put_field(&mut this, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;", key) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", parent) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$Entry", "color", "Z", true).await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -74,8 +77,9 @@ impl TreeMapEntry { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let old_value = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old_value = jvm.get_field(&this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value) + .await?; Ok(old_value) } @@ -84,7 +88,7 @@ impl TreeMapEntry { return Ok(false); } - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; let other_key: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getKey", "()Ljava/lang/Object;", ()) .await?; @@ -97,7 +101,7 @@ impl TreeMapEntry { if !keys_equal { return Ok(false); } - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; let other_value: ClassInstanceRef = jvm .invoke_virtual(&other, &other.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; @@ -110,8 +114,8 @@ impl TreeMapEntry { } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let key: ClassInstanceRef = jvm.get_field(&this, "key", "Ljava/lang/Object;").await?; - let value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let value: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?; let key_hash = if key.is_null() { 0 } else { diff --git a/rustjava-runtime/src/classes/java/util/tree_map_entry_set.rs b/rustjava-runtime/src/classes/java/util/tree_map_entry_set.rs index 5d32bc74..c053bd48 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_entry_set.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_entry_set.rs @@ -30,11 +30,12 @@ impl TreeMapEntrySet { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;", map) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await } @@ -42,7 +43,7 @@ impl TreeMapEntrySet { if candidate.is_null() || !jvm.is_instance(candidate.as_ref(), "java/util/Map$Entry") { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;").await?; let value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; @@ -82,7 +83,7 @@ impl TreeMapEntrySet { if candidate.is_null() || !jvm.is_instance(candidate.as_ref(), "java/util/Map$Entry") { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;").await?; let value: ClassInstanceRef = jvm .invoke_virtual(&candidate, &candidate.class_definition().name(), "getValue", "()Ljava/lang/Object;", ()) .await?; @@ -132,12 +133,12 @@ impl TreeMapEntrySet { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "clear", "()V", ()).await } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$EntrySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "entryIterator", "()Ljava/util/Iterator;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_key_iterator.rs b/rustjava-runtime/src/classes/java/util/tree_map_key_iterator.rs index b0fc8122..c55e36df 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_key_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_key_iterator.rs @@ -52,6 +52,6 @@ impl TreeMapKeyIterator { async fn next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { let entry = TreeMapPrivateEntryIterator::next_entry(jvm, this).await?; - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_key_set.rs b/rustjava-runtime/src/classes/java/util/tree_map_key_set.rs index 351622f8..b8d92a93 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_key_set.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_key_set.rs @@ -30,22 +30,23 @@ impl TreeMapKeySet { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;", map) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,)) .await } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, key: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;").await?; if !jvm .invoke_virtual::<_, bool>( &map, @@ -71,12 +72,12 @@ impl TreeMapKeySet { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "clear", "()V", ()).await } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$KeySet", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "keyIterator", "()Ljava/util/Iterator;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_private_entry_iterator.rs b/rustjava-runtime/src/classes/java/util/tree_map_private_entry_iterator.rs index 7951af4f..c821aa97 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_private_entry_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_private_entry_iterator.rs @@ -49,41 +49,80 @@ impl TreeMapPrivateEntryIterator { to_end: bool, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/TreeMap;", map).await?; - jvm.put_field(&mut this, "next", "Ljava/util/TreeMap$Entry;", next).await?; - jvm.put_field(&mut this, "upper", "Ljava/lang/Object;", upper).await?; - jvm.put_field(&mut this, "toEnd", "Z", to_end).await + jvm.put_field(&mut this, "java/util/TreeMap$PrivateEntryIterator", "map", "Ljava/util/TreeMap;", map) + .await?; + jvm.put_field( + &mut this, + "java/util/TreeMap$PrivateEntryIterator", + "next", + "Ljava/util/TreeMap$Entry;", + next, + ) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$PrivateEntryIterator", "upper", "Ljava/lang/Object;", upper) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$PrivateEntryIterator", "toEnd", "Z", to_end) + .await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let next: ClassInstanceRef = jvm.get_field(&this, "next", "Ljava/util/TreeMap$Entry;").await?; + let next: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "next", "Ljava/util/TreeMap$Entry;") + .await?; if next.is_null() { return Ok(false); } - if jvm.get_field::(&this, "toEnd", "Z").await? { + if jvm + .get_field::(&this, "java/util/TreeMap$PrivateEntryIterator", "toEnd", "Z") + .await? + { return Ok(true); } - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/TreeMap;").await?; - let key: ClassInstanceRef = jvm.get_field(&next, "key", "Ljava/lang/Object;").await?; - let upper: ClassInstanceRef = jvm.get_field(&this, "upper", "Ljava/lang/Object;").await?; + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "map", "Ljava/util/TreeMap;") + .await?; + let key: ClassInstanceRef = jvm.get_field(&next, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let upper: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "upper", "Ljava/lang/Object;") + .await?; Ok(TreeMap::compare(jvm, &map, &key, &upper).await? < 0) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: ClassInstanceRef = jvm.get_field(&this, "lastReturned", "Ljava/util/TreeMap$Entry;").await?; + let last_returned: ClassInstanceRef = jvm + .get_field( + &this, + "java/util/TreeMap$PrivateEntryIterator", + "lastReturned", + "Ljava/util/TreeMap$Entry;", + ) + .await?; if last_returned.is_null() { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let left: ClassInstanceRef = jvm.get_field(&last_returned, "left", "Ljava/util/TreeMap$Entry;").await?; - let right: ClassInstanceRef = jvm.get_field(&last_returned, "right", "Ljava/util/TreeMap$Entry;").await?; + let left: ClassInstanceRef = jvm + .get_field(&last_returned, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let right: ClassInstanceRef = jvm + .get_field(&last_returned, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !left.is_null() && !right.is_null() { - jvm.put_field(&mut this, "next", "Ljava/util/TreeMap$Entry;", last_returned.clone()) - .await?; + jvm.put_field( + &mut this, + "java/util/TreeMap$PrivateEntryIterator", + "next", + "Ljava/util/TreeMap$Entry;", + last_returned.clone(), + ) + .await?; } - let mut map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/TreeMap;").await?; + let mut map: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "map", "Ljava/util/TreeMap;") + .await?; TreeMap::delete_entry(jvm, &mut map, last_returned).await?; jvm.put_field( &mut this, + "java/util/TreeMap$PrivateEntryIterator", "lastReturned", "Ljava/util/TreeMap$Entry;", ClassInstanceRef::::from(None), @@ -92,22 +131,44 @@ impl TreeMapPrivateEntryIterator { } pub(super) async fn next_entry(jvm: &Jvm, mut this: ClassInstanceRef) -> Result> { - let next: ClassInstanceRef = jvm.get_field(&this, "next", "Ljava/util/TreeMap$Entry;").await?; + let next: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "next", "Ljava/util/TreeMap$Entry;") + .await?; if next.is_null() { return Err(jvm.exception("java/util/NoSuchElementException", "TreeMap iterator exhausted").await); } - if !jvm.get_field::(&this, "toEnd", "Z").await? { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/TreeMap;").await?; - let key: ClassInstanceRef = jvm.get_field(&next, "key", "Ljava/lang/Object;").await?; - let upper: ClassInstanceRef = jvm.get_field(&this, "upper", "Ljava/lang/Object;").await?; + if !jvm + .get_field::(&this, "java/util/TreeMap$PrivateEntryIterator", "toEnd", "Z") + .await? + { + let map: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "map", "Ljava/util/TreeMap;") + .await?; + let key: ClassInstanceRef = jvm.get_field(&next, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let upper: ClassInstanceRef = jvm + .get_field(&this, "java/util/TreeMap$PrivateEntryIterator", "upper", "Ljava/lang/Object;") + .await?; if TreeMap::compare(jvm, &map, &key, &upper).await? >= 0 { return Err(jvm.exception("java/util/NoSuchElementException", "TreeMap iterator exhausted").await); } } let successor = TreeMap::successor(jvm, next.clone()).await?; - jvm.put_field(&mut this, "next", "Ljava/util/TreeMap$Entry;", successor).await?; - jvm.put_field(&mut this, "lastReturned", "Ljava/util/TreeMap$Entry;", next.clone()) - .await?; + jvm.put_field( + &mut this, + "java/util/TreeMap$PrivateEntryIterator", + "next", + "Ljava/util/TreeMap$Entry;", + successor, + ) + .await?; + jvm.put_field( + &mut this, + "java/util/TreeMap$PrivateEntryIterator", + "lastReturned", + "Ljava/util/TreeMap$Entry;", + next.clone(), + ) + .await?; Ok(next) } } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_sub_map.rs b/rustjava-runtime/src/classes/java/util/tree_map_sub_map.rs index 128f91fe..eacadfe8 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_sub_map.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_sub_map.rs @@ -114,11 +114,14 @@ impl TreeMapSubMap { return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey > toKey").await); } let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "", "()V", ()).await?; - jvm.put_field(&mut this, "m", "Ljava/util/TreeMap;", map).await?; - jvm.put_field(&mut this, "fromStart", "Z", from_start).await?; - jvm.put_field(&mut this, "fromKey", "Ljava/lang/Object;", from_key).await?; - jvm.put_field(&mut this, "toEnd", "Z", to_end).await?; - jvm.put_field(&mut this, "toKey", "Ljava/lang/Object;", to_key).await + jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;", map) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "fromStart", "Z", from_start).await?; + jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;", from_key) + .await?; + jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "toEnd", "Z", to_end).await?; + jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;", to_key) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { @@ -142,7 +145,7 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &key, false).await? { return Ok(false); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; Ok(!TreeMap::find_entry(jvm, &map, &key).await?.is_null()) } @@ -174,12 +177,12 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &key, false).await? { return Ok(None.into()); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; let entry = TreeMap::find_entry(jvm, &map, &key).await?; if entry.is_null() { return Ok(None.into()); } - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await } async fn put( @@ -192,7 +195,7 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &key, false).await? { return Err(jvm.exception("java/lang/IllegalArgumentException", "key outside range").await); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; jvm.invoke_virtual( &map, "java/util/TreeMap", @@ -212,7 +215,7 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &key, false).await? { return Ok(None.into()); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; jvm.invoke_virtual(&map, "java/util/TreeMap", "remove", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,)) .await } @@ -236,7 +239,7 @@ impl TreeMapSubMap { } async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; jvm.invoke_virtual(&map, "java/util/TreeMap", "comparator", "()Ljava/util/Comparator;", ()) .await } @@ -246,7 +249,7 @@ impl TreeMapSubMap { if entry.is_null() { return Err(jvm.exception("java/util/NoSuchElementException", "empty subMap").await); } - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } async fn last_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { @@ -254,7 +257,7 @@ impl TreeMapSubMap { if entry.is_null() { return Err(jvm.exception("java/util/NoSuchElementException", "empty subMap").await); } - jvm.get_field(&entry, "key", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await } async fn sub_map( @@ -264,7 +267,7 @@ impl TreeMapSubMap { from_key: ClassInstanceRef, to_key: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; if !Self::in_range(jvm, &this, &from_key, false).await? { return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey outside range").await); } @@ -293,9 +296,9 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &to_key, true).await? { return Err(jvm.exception("java/lang/IllegalArgumentException", "endpoint outside range").await); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; - let from_start: bool = jvm.get_field(&this, "fromStart", "Z").await?; - let from_key: ClassInstanceRef = jvm.get_field(&this, "fromKey", "Ljava/lang/Object;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; + let from_start: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "fromStart", "Z").await?; + let from_key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?; Ok(jvm .new_class( "java/util/TreeMap$SubMap", @@ -315,9 +318,9 @@ impl TreeMapSubMap { if !Self::in_range(jvm, &this, &from_key, false).await? { return Err(jvm.exception("java/lang/IllegalArgumentException", "endpoint outside range").await); } - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; - let to_end: bool = jvm.get_field(&this, "toEnd", "Z").await?; - let to_key: ClassInstanceRef = jvm.get_field(&this, "toKey", "Ljava/lang/Object;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; + let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?; + let to_key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; Ok(jvm .new_class( "java/util/TreeMap$SubMap", @@ -350,10 +353,10 @@ impl TreeMapSubMap { } async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; let first = Self::first_entry(jvm, &this).await?; - let to_end: bool = jvm.get_field(&this, "toEnd", "Z").await?; - let to_key: ClassInstanceRef = jvm.get_field(&this, "toKey", "Ljava/lang/Object;").await?; + let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?; + let to_key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; Ok(jvm .new_class( "java/util/TreeMap$KeyIterator", @@ -365,10 +368,10 @@ impl TreeMapSubMap { } async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; let first = Self::first_entry(jvm, &this).await?; - let to_end: bool = jvm.get_field(&this, "toEnd", "Z").await?; - let to_key: ClassInstanceRef = jvm.get_field(&this, "toKey", "Ljava/lang/Object;").await?; + let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?; + let to_key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; Ok(jvm .new_class( "java/util/TreeMap$ValueIterator", @@ -380,10 +383,10 @@ impl TreeMapSubMap { } async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/TreeMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; let first = Self::first_entry(jvm, &this).await?; - let to_end: bool = jvm.get_field(&this, "toEnd", "Z").await?; - let to_key: ClassInstanceRef = jvm.get_field(&this, "toKey", "Ljava/lang/Object;").await?; + let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?; + let to_key: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; Ok(jvm .new_class( "java/util/TreeMap$EntryIterator", @@ -395,15 +398,15 @@ impl TreeMapSubMap { } async fn in_range(jvm: &Jvm, this: &ClassInstanceRef, key: &ClassInstanceRef, allow_equal_upper: bool) -> Result { - let map: ClassInstanceRef = jvm.get_field(this, "m", "Ljava/util/TreeMap;").await?; - if !jvm.get_field::(this, "fromStart", "Z").await? { - let from_key: ClassInstanceRef = jvm.get_field(this, "fromKey", "Ljava/lang/Object;").await?; + let map: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; + if !jvm.get_field::(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? { + let from_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?; if TreeMap::compare(jvm, &map, key, &from_key).await? < 0 { return Ok(false); } } - if !jvm.get_field::(this, "toEnd", "Z").await? { - let to_key: ClassInstanceRef = jvm.get_field(this, "toKey", "Ljava/lang/Object;").await?; + if !jvm.get_field::(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? { + let to_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; let comparison = TreeMap::compare(jvm, &map, key, &to_key).await?; if comparison > 0 || (!allow_equal_upper && comparison == 0) { return Ok(false); @@ -413,18 +416,18 @@ impl TreeMapSubMap { } async fn first_entry(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(this, "m", "Ljava/util/TreeMap;").await?; - let entry = if jvm.get_field::(this, "fromStart", "Z").await? { + let map: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; + let entry = if jvm.get_field::(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? { TreeMap::first_entry(jvm, &map).await? } else { - let from_key: ClassInstanceRef = jvm.get_field(this, "fromKey", "Ljava/lang/Object;").await?; + let from_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?; TreeMap::ceiling_entry(jvm, &map, &from_key).await? }; - if entry.is_null() || jvm.get_field::(this, "toEnd", "Z").await? { + if entry.is_null() || jvm.get_field::(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? { return Ok(entry); } - let key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; - let to_key: ClassInstanceRef = jvm.get_field(this, "toKey", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let to_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; if TreeMap::compare(jvm, &map, &key, &to_key).await? >= 0 { Ok(None.into()) } else { @@ -433,18 +436,18 @@ impl TreeMapSubMap { } async fn last_entry(jvm: &Jvm, this: &ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(this, "m", "Ljava/util/TreeMap;").await?; - let entry = if jvm.get_field::(this, "toEnd", "Z").await? { + let map: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?; + let entry = if jvm.get_field::(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? { TreeMap::last_entry(jvm, &map).await? } else { - let to_key: ClassInstanceRef = jvm.get_field(this, "toKey", "Ljava/lang/Object;").await?; + let to_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?; TreeMap::lower_entry(jvm, &map, &to_key).await? }; - if entry.is_null() || jvm.get_field::(this, "fromStart", "Z").await? { + if entry.is_null() || jvm.get_field::(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? { return Ok(entry); } - let key: ClassInstanceRef = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?; - let from_key: ClassInstanceRef = jvm.get_field(this, "fromKey", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; + let from_key: ClassInstanceRef = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?; if TreeMap::compare(jvm, &map, &key, &from_key).await? < 0 { Ok(None.into()) } else { diff --git a/rustjava-runtime/src/classes/java/util/tree_map_value_iterator.rs b/rustjava-runtime/src/classes/java/util/tree_map_value_iterator.rs index 071cea05..473ce9cb 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_value_iterator.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_value_iterator.rs @@ -52,6 +52,6 @@ impl TreeMapValueIterator { async fn next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { let entry = TreeMapPrivateEntryIterator::next_entry(jvm, this).await?; - jvm.get_field(&entry, "value", "Ljava/lang/Object;").await + jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await } } diff --git a/rustjava-runtime/src/classes/java/util/tree_map_values.rs b/rustjava-runtime/src/classes/java/util/tree_map_values.rs index 7c10b05b..12ddf0d0 100644 --- a/rustjava-runtime/src/classes/java/util/tree_map_values.rs +++ b/rustjava-runtime/src/classes/java/util/tree_map_values.rs @@ -30,22 +30,23 @@ impl TreeMapValues { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, map: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "", "()V", ()).await?; - jvm.put_field(&mut this, "map", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;", map) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "containsValue", "(Ljava/lang/Object;)Z", (value,)) .await } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, value: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;").await?; let iterator: ClassInstanceRef = jvm .invoke_virtual(&map, &map.class_definition().name(), "valueIterator", "()Ljava/util/Iterator;", ()) .await?; @@ -73,12 +74,12 @@ impl TreeMapValues { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "clear", "()V", ()).await } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "map", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeMap$Values", "map", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "valueIterator", "()Ljava/util/Iterator;", ()) .await } diff --git a/rustjava-runtime/src/classes/java/util/tree_set.rs b/rustjava-runtime/src/classes/java/util/tree_set.rs index 2a65a390..e565c423 100644 --- a/rustjava-runtime/src/classes/java/util/tree_set.rs +++ b/rustjava-runtime/src/classes/java/util/tree_set.rs @@ -71,7 +71,7 @@ impl TreeSet { let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; let map: ClassInstanceRef = jvm.new_class("java/util/TreeMap", "()V", ()).await?.into(); let mut this = this; - jvm.put_field(&mut this, "m", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await } async fn init_comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, comparator: ClassInstanceRef) -> Result<()> { @@ -81,7 +81,7 @@ impl TreeSet { .await? .into(); let mut this = this; - jvm.put_field(&mut this, "m", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await } async fn init_collection(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, collection: ClassInstanceRef) -> Result<()> { @@ -116,22 +116,22 @@ impl TreeSet { return Err(jvm.exception("java/lang/NullPointerException", "map").await); } let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "m", "Ljava/util/SortedMap;", map).await + jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (element,)) .await } async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; let present: ClassInstanceRef = jvm.get_static_field("java/util/TreeSet", "PRESENT", "Ljava/lang/Object;").await?; let old: ClassInstanceRef = jvm .invoke_virtual( @@ -146,7 +146,7 @@ impl TreeSet { } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; if !jvm .invoke_virtual::<_, bool>( &map, @@ -172,12 +172,12 @@ impl TreeSet { } async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result<()> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "clear", "()V", ()).await } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; let keys: ClassInstanceRef = jvm .invoke_virtual(&map, &map.class_definition().name(), "keySet", "()Ljava/util/Set;", ()) .await?; @@ -186,19 +186,19 @@ impl TreeSet { } async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ()) .await } async fn first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "firstKey", "()Ljava/lang/Object;", ()) .await } async fn last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; jvm.invoke_virtual(&map, &map.class_definition().name(), "lastKey", "()Ljava/lang/Object;", ()) .await } @@ -210,7 +210,7 @@ impl TreeSet { from: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -229,7 +229,7 @@ impl TreeSet { this: ClassInstanceRef, to: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, @@ -248,7 +248,7 @@ impl TreeSet { this: ClassInstanceRef, from: ClassInstanceRef, ) -> Result> { - let map: ClassInstanceRef = jvm.get_field(&this, "m", "Ljava/util/SortedMap;").await?; + let map: ClassInstanceRef = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?; let range: ClassInstanceRef = jvm .invoke_virtual( &map, diff --git a/rustjava-runtime/src/classes/java/util/unknown_format_conversion_exception.rs b/rustjava-runtime/src/classes/java/util/unknown_format_conversion_exception.rs index 09841d4c..446e83f8 100644 --- a/rustjava-runtime/src/classes/java/util/unknown_format_conversion_exception.rs +++ b/rustjava-runtime/src/classes/java/util/unknown_format_conversion_exception.rs @@ -30,15 +30,25 @@ impl UnknownFormatConversionException { return Err(jvm.exception("java/lang/NullPointerException", "conversion is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "conversion", "Ljava/lang/String;", conversion).await + jvm.put_field( + &mut this, + "java/util/UnknownFormatConversionException", + "conversion", + "Ljava/lang/String;", + conversion, + ) + .await } async fn get_conversion(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "conversion", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/UnknownFormatConversionException", "conversion", "Ljava/lang/String;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let conversion: ClassInstanceRef = jvm.get_field(&this, "conversion", "Ljava/lang/String;").await?; + let conversion: ClassInstanceRef = jvm + .get_field(&this, "java/util/UnknownFormatConversionException", "conversion", "Ljava/lang/String;") + .await?; JavaLangString::from_rust_string( jvm, &alloc::format!("Conversion = '{}'", JavaLangString::to_rust_string(jvm, &conversion).await?), diff --git a/rustjava-runtime/src/classes/java/util/unknown_format_flags_exception.rs b/rustjava-runtime/src/classes/java/util/unknown_format_flags_exception.rs index e3e6d6ca..1832f70b 100644 --- a/rustjava-runtime/src/classes/java/util/unknown_format_flags_exception.rs +++ b/rustjava-runtime/src/classes/java/util/unknown_format_flags_exception.rs @@ -30,15 +30,19 @@ impl UnknownFormatFlagsException { return Err(jvm.exception("java/lang/NullPointerException", "flags is null").await); } let _: () = jvm.invoke_special(&this, "java/util/IllegalFormatException", "", "()V", ()).await?; - jvm.put_field(&mut this, "flags", "Ljava/lang/String;", flags).await + jvm.put_field(&mut this, "java/util/UnknownFormatFlagsException", "flags", "Ljava/lang/String;", flags) + .await } async fn get_flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "flags", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/UnknownFormatFlagsException", "flags", "Ljava/lang/String;") + .await } async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let flags: ClassInstanceRef = jvm.get_field(&this, "flags", "Ljava/lang/String;").await?; + let flags: ClassInstanceRef = jvm + .get_field(&this, "java/util/UnknownFormatFlagsException", "flags", "Ljava/lang/String;") + .await?; JavaLangString::from_rust_string(jvm, &alloc::format!("Flags = {}", JavaLangString::to_rust_string(jvm, &flags).await?)) .await .map(Into::into) diff --git a/rustjava-runtime/src/classes/java/util/vector.rs b/rustjava-runtime/src/classes/java/util/vector.rs index 17476e2d..69430920 100644 --- a/rustjava-runtime/src/classes/java/util/vector.rs +++ b/rustjava-runtime/src/classes/java/util/vector.rs @@ -287,9 +287,11 @@ impl Vector { let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; let element_data = jvm.instantiate_array("Ljava/lang/Object;", capacity as _).await?; - jvm.put_field(&mut this, "elementData", "[Ljava/lang/Object;", element_data).await?; - jvm.put_field(&mut this, "elementCount", "I", 0).await?; - jvm.put_field(&mut this, "capacityIncrement", "I", capacity_increment).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", element_data) + .await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", 0).await?; + jvm.put_field(&mut this, "java/util/Vector", "capacityIncrement", "I", capacity_increment) + .await?; Ok(()) } @@ -317,7 +319,7 @@ impl Vector { } async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; Ok(jvm.array_length(&element_data).await? as i32) } @@ -333,8 +335,8 @@ impl Vector { return Err(jvm.exception("java/lang/NullPointerException", "destination").await); } - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let elements: Vec> = jvm.load_array(&element_data, 0, element_count as usize).await?; jvm.store_array(&mut destination, 0, elements).await } @@ -364,12 +366,13 @@ impl Vector { async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.Vector::add({this:?}, {element:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?; - jvm.put_field(&mut this, "elementCount", "I", element_count + 1).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1) + .await?; Ok(true) } @@ -377,7 +380,7 @@ impl Vector { async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32, element: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Vector::add({this:?}, {index:?}, {element:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index > element_count { return Err(jvm .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {element_count}")) @@ -391,12 +394,13 @@ impl Vector { async fn add_element(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Vector::addElement({this:?}, {element:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?; - jvm.put_field(&mut this, "elementCount", "I", element_count + 1).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1) + .await?; Ok(()) } @@ -410,7 +414,7 @@ impl Vector { ) -> Result<()> { tracing::debug!("java.util.Vector::insertElementAt({this:?}, {element:?}, {index:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index > element_count { return Err(jvm .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} > {element_count}")) @@ -418,7 +422,7 @@ impl Vector { } Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let num_to_move = element_count - index; if num_to_move > 0 { @@ -427,7 +431,8 @@ impl Vector { } jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?; - jvm.put_field(&mut this, "elementCount", "I", element_count + 1).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1) + .await?; Ok(()) } @@ -435,14 +440,14 @@ impl Vector { async fn element_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { tracing::debug!("java.util.Vector::elementAt({this:?}, {index:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index >= element_count { return Err(jvm .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}")) .await); } - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let element: ClassInstanceRef = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap(); Ok(element) @@ -464,14 +469,14 @@ impl Vector { ) -> Result> { tracing::debug!("java.util.Vector::set({this:?}, {index:?}, {element:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index >= element_count { return Err(jvm .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}")) .await); } - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let old_element: ClassInstanceRef = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap(); jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?; @@ -481,13 +486,13 @@ impl Vector { async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Vector::size({this:?})"); - jvm.get_field(&this, "elementCount", "I").await + jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await } async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.Vector::isEmpty({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; Ok(element_count == 0) } @@ -495,14 +500,14 @@ impl Vector { async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result> { tracing::debug!("java.util.Vector::remove({this:?}, {index:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index >= element_count { return Err(jvm .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}")) .await); } - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let removed: ClassInstanceRef = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap(); let num_to_move = element_count - index - 1; @@ -514,7 +519,8 @@ impl Vector { let null_ref: ClassInstanceRef = None.into(); jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref)) .await?; - jvm.put_field(&mut this, "elementCount", "I", element_count - 1).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1) + .await?; Ok(removed) } @@ -529,15 +535,15 @@ impl Vector { async fn remove_all_elements(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Vector::removeAllElements({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let nulls: Vec> = (0..element_count).map(|_| None.into()).collect(); if !nulls.is_empty() { jvm.store_array(&mut element_data, 0, nulls).await?; } - jvm.put_field(&mut this, "elementCount", "I", 0).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", 0).await?; Ok(()) } @@ -545,14 +551,14 @@ impl Vector { async fn remove_element_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result<()> { tracing::debug!("java.util.Vector::removeElementAt({this:?}, {index:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index < 0 || index >= element_count { return Err(jvm .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}")) .await); } - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let num_to_move = element_count - index - 1; if num_to_move > 0 { @@ -563,7 +569,8 @@ impl Vector { let null_ref: ClassInstanceRef = None.into(); jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref)) .await?; - jvm.put_field(&mut this, "elementCount", "I", element_count - 1).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1) + .await?; Ok(()) } @@ -588,8 +595,8 @@ impl Vector { return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &index.to_string()).await); } - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; for i in index..element_count { let item: ClassInstanceRef = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap(); @@ -623,7 +630,7 @@ impl Vector { async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; let index: i32 = jvm .invoke_virtual( @@ -647,7 +654,7 @@ impl Vector { ) -> Result { tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?}, {index:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if index >= element_count { return Err(jvm @@ -655,7 +662,7 @@ impl Vector { .await); } - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; for i in (0..=index).rev() { let item: ClassInstanceRef = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap(); @@ -679,13 +686,13 @@ impl Vector { async fn first_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Vector::firstElement({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if element_count == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await); } - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let element: ClassInstanceRef = jvm.load_array(&element_data, 0, 1).await?.into_iter().next().unwrap(); Ok(element) @@ -694,12 +701,12 @@ impl Vector { async fn last_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Vector::lastElement({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if element_count == 0 { return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await); } - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; Ok(jvm .load_array::>(&element_data, (element_count - 1) as usize, 1) .await? @@ -734,15 +741,15 @@ impl Vector { return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &new_size.to_string()).await); } - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; if new_size > element_count { Self::ensure_capacity(jvm, &mut this, new_size as usize).await?; } else if new_size < element_count { - let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let nulls: Vec> = (new_size..element_count).map(|_| None.into()).collect(); jvm.store_array(&mut element_data, new_size as usize, nulls).await?; } - jvm.put_field(&mut this, "elementCount", "I", new_size).await + jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", new_size).await } async fn remove_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result { @@ -769,8 +776,8 @@ impl Vector { async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result>> { tracing::debug!("java.util.Vector::toArray({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let element_data: ClassInstanceRef> = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let element_data: ClassInstanceRef> = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; Self::copy_to_array(jvm, &element_data, element_count).await } @@ -885,15 +892,16 @@ impl Vector { async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { tracing::debug!("java.util.Vector::trimToSize({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let current_capacity = jvm.array_length(&element_data).await?; if (element_count as usize) < current_capacity { let elements: Vec> = jvm.load_array(&element_data, 0, element_count as _).await?; let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", element_count as _).await?; jvm.store_array(&mut new_element_data, 0, elements).await?; - jvm.put_field(&mut this, "elementData", "[Ljava/lang/Object;", new_element_data).await?; + jvm.put_field(&mut this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data) + .await?; } Ok(()) @@ -902,8 +910,8 @@ impl Vector { async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.Vector::toString({this:?})"); - let element_count: i32 = jvm.get_field(&this, "elementCount", "I").await?; - let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?; + let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?; + let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let elements: Vec> = jvm.load_array(&element_data, 0, element_count as usize).await?; let mut result = RustString::from("["); for (index, element) in elements.into_iter().enumerate() { @@ -928,11 +936,11 @@ impl Vector { } async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef, min_capacity: usize) -> Result<()> { - let element_data = jvm.get_field(this, "elementData", "[Ljava/lang/Object;").await?; + let element_data = jvm.get_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?; let current_capacity = jvm.array_length(&element_data).await?; if min_capacity > current_capacity { - let capacity_increment: i32 = jvm.get_field(this, "capacityIncrement", "I").await?; + let capacity_increment: i32 = jvm.get_field(this, "java/util/Vector", "capacityIncrement", "I").await?; let new_capacity = if capacity_increment > 0 { current_capacity + capacity_increment as usize } else { @@ -940,12 +948,13 @@ impl Vector { }; let new_capacity = new_capacity.max(min_capacity); - let element_count: i32 = jvm.get_field(this, "elementCount", "I").await?; + let element_count: i32 = jvm.get_field(this, "java/util/Vector", "elementCount", "I").await?; let old_elements: Vec> = jvm.load_array(&element_data, 0, element_count as _).await?; let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", new_capacity).await?; jvm.store_array(&mut new_element_data, 0, old_elements).await?; - jvm.put_field(this, "elementData", "[Ljava/lang/Object;", new_element_data).await?; + jvm.put_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data) + .await?; } Ok(()) diff --git a/rustjava-runtime/src/classes/java/util/vector_itr.rs b/rustjava-runtime/src/classes/java/util/vector_itr.rs index 169ddc84..644e0c90 100644 --- a/rustjava-runtime/src/classes/java/util/vector_itr.rs +++ b/rustjava-runtime/src/classes/java/util/vector_itr.rs @@ -55,80 +55,81 @@ impl VectorItr { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "list iterator index").await); } let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "list", "Ljava/util/Vector;", list).await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;", list) + .await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "lastReturned", "I", -1).await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await?; Ok(cursor < jvm.invoke_virtual::<_, i32>(&list, "java/util/Vector", "size", "()I", ()).await?) } async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await?; if cursor >= jvm.invoke_virtual::<_, i32>(&list, "java/util/Vector", "size", "()I", ()).await? { return Err(jvm.exception("java/util/NoSuchElementException", "Vector iterator exhausted").await); } let element = jvm .invoke_virtual(&list, "java/util/Vector", "get", "(I)Ljava/lang/Object;", (cursor,)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", cursor).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "lastReturned", "I", cursor).await?; Ok(element) } async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? > 0) + Ok(jvm.get_field::(&this, "java/util/Vector$Itr", "cursor", "I").await? > 0) } async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await?; if cursor <= 0 { return Err(jvm.exception("java/util/NoSuchElementException", "Vector iterator exhausted").await); } let index = cursor - 1; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; let element = jvm .invoke_virtual(&list, "java/util/Vector", "get", "(I)Ljava/lang/Object;", (index,)) .await?; - jvm.put_field(&mut this, "cursor", "I", index).await?; - jvm.put_field(&mut this, "lastReturned", "I", index).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "cursor", "I", index).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "lastReturned", "I", index).await?; Ok(element) } async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "cursor", "I").await + jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await } async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - Ok(jvm.get_field::(&this, "cursor", "I").await? - 1) + Ok(jvm.get_field::(&this, "java/util/Vector$Itr", "cursor", "I").await? - 1) } async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; let _: ClassInstanceRef = jvm .invoke_virtual(&list, "java/util/Vector", "remove", "(I)Ljava/lang/Object;", (last_returned,)) .await?; - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await?; if last_returned < cursor { - jvm.put_field(&mut this, "cursor", "I", cursor - 1).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "cursor", "I", cursor - 1).await?; } - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/Vector$Itr", "lastReturned", "I", -1).await } async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?; + let last_returned: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "lastReturned", "I").await?; if last_returned < 0 { return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await); } - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &list, @@ -142,12 +143,12 @@ impl VectorItr { } async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef) -> Result<()> { - let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?; - let list: ClassInstanceRef = jvm.get_field(&this, "list", "Ljava/util/Vector;").await?; + let cursor: i32 = jvm.get_field(&this, "java/util/Vector$Itr", "cursor", "I").await?; + let list: ClassInstanceRef = jvm.get_field(&this, "java/util/Vector$Itr", "list", "Ljava/util/Vector;").await?; let _: () = jvm .invoke_virtual(&list, "java/util/Vector", "add", "(ILjava/lang/Object;)V", (cursor, element)) .await?; - jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?; - jvm.put_field(&mut this, "lastReturned", "I", -1).await + jvm.put_field(&mut this, "java/util/Vector$Itr", "cursor", "I", cursor + 1).await?; + jvm.put_field(&mut this, "java/util/Vector$Itr", "lastReturned", "I", -1).await } } diff --git a/rustjava-runtime/src/classes/java/util/zip/zip_entry.rs b/rustjava-runtime/src/classes/java/util/zip/zip_entry.rs index 2a06d4eb..ef4146b1 100644 --- a/rustjava-runtime/src/classes/java/util/zip/zip_entry.rs +++ b/rustjava-runtime/src/classes/java/util/zip/zip_entry.rs @@ -40,7 +40,8 @@ impl ZipEntry { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; + jvm.put_field(&mut this, "java/util/zip/ZipEntry", "name", "Ljava/lang/String;", name) + .await?; Ok(()) } @@ -55,11 +56,12 @@ impl ZipEntry { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - let name: ClassInstanceRef = jvm.get_field(&zip_entry, "name", "Ljava/lang/String;").await?; - let size: i64 = jvm.get_field(&zip_entry, "size", "J").await?; + let name: ClassInstanceRef = jvm.get_field(&zip_entry, "java/util/zip/ZipEntry", "name", "Ljava/lang/String;").await?; + let size: i64 = jvm.get_field(&zip_entry, "java/util/zip/ZipEntry", "size", "J").await?; - jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?; - jvm.put_field(&mut this, "size", "J", size).await?; + jvm.put_field(&mut this, "java/util/zip/ZipEntry", "name", "Ljava/lang/String;", name) + .await?; + jvm.put_field(&mut this, "java/util/zip/ZipEntry", "size", "J", size).await?; Ok(()) } @@ -67,13 +69,13 @@ impl ZipEntry { async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.zip.ZipEntry::getName({this:?})"); - jvm.get_field(&this, "name", "Ljava/lang/String;").await + jvm.get_field(&this, "java/util/zip/ZipEntry", "name", "Ljava/lang/String;").await } async fn set_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, size: i64) -> Result<()> { tracing::debug!("java.util.zip.ZipEntry::setSize({this:?}, {size:?})"); - jvm.put_field(&mut this, "size", "J", size).await?; + jvm.put_field(&mut this, "java/util/zip/ZipEntry", "size", "J", size).await?; Ok(()) } @@ -81,6 +83,6 @@ impl ZipEntry { async fn get_size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.zip.ZipEntry::getSize({this:?})"); - jvm.get_field(&this, "size", "J").await + jvm.get_field(&this, "java/util/zip/ZipEntry", "size", "J").await } } diff --git a/rustjava-runtime/src/classes/java/util/zip/zip_file.rs b/rustjava-runtime/src/classes/java/util/zip/zip_file.rs index c1baad02..1d5478f7 100644 --- a/rustjava-runtime/src/classes/java/util/zip/zip_file.rs +++ b/rustjava-runtime/src/classes/java/util/zip/zip_file.rs @@ -51,7 +51,7 @@ impl ZipFile { } async fn get_zip_archive(jvm: &Jvm, this: &ClassInstanceRef) -> Result>>> { - let zip_data: ClassInstanceRef> = jvm.get_field(this, "zipData", "[B").await?; + let zip_data: ClassInstanceRef> = jvm.get_field(this, "java/util/zip/ZipFile", "zipData", "[B").await?; let length = jvm.array_length(&zip_data).await?; let mut buf = vec![0u8; length]; jvm.array_raw_buffer(&zip_data).await?.read(0, &mut buf)?; @@ -73,7 +73,7 @@ impl ZipFile { let buf = jvm.instantiate_array("B", length as _).await?; let _: i32 = jvm.invoke_virtual(&is, "java/io/InputStream", "read", "([B)I", (buf.clone(),)).await?; - jvm.put_field(&mut this, "zipData", "[B", buf).await?; + jvm.put_field(&mut this, "java/util/zip/ZipFile", "zipData", "[B", buf).await?; // the constructor throws ZipException for a malformed archive let _ = Self::get_zip_archive(jvm, &this).await?; diff --git a/rustjava-runtime/src/classes/java/util/zip/zip_file_entries.rs b/rustjava-runtime/src/classes/java/util/zip/zip_file_entries.rs index 37fd754d..9618e7e2 100644 --- a/rustjava-runtime/src/classes/java/util/zip/zip_file_entries.rs +++ b/rustjava-runtime/src/classes/java/util/zip/zip_file_entries.rs @@ -51,9 +51,11 @@ impl ZipFileEntries { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "zipFile", "Ljava/util/zip/ZipFile;", zip_file).await?; - jvm.put_field(&mut this, "names", "[Ljava/lang/String;", names).await?; - jvm.put_field(&mut this, "i", "I", 0).await?; + jvm.put_field(&mut this, "java/util/zip/ZipFile$Entries", "zipFile", "Ljava/util/zip/ZipFile;", zip_file) + .await?; + jvm.put_field(&mut this, "java/util/zip/ZipFile$Entries", "names", "[Ljava/lang/String;", names) + .await?; + jvm.put_field(&mut this, "java/util/zip/ZipFile$Entries", "i", "I", 0).await?; Ok(()) } @@ -61,8 +63,10 @@ impl ZipFileEntries { async fn has_more_elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { tracing::debug!("java.util.zip.ZipFile$Entries::hasMoreElements({this:?})"); - let i: i32 = jvm.get_field(&this, "i", "I").await?; - let names: ClassInstanceRef> = jvm.get_field(&this, "names", "[Ljava/lang/String;").await?; + let i: i32 = jvm.get_field(&this, "java/util/zip/ZipFile$Entries", "i", "I").await?; + let names: ClassInstanceRef> = jvm + .get_field(&this, "java/util/zip/ZipFile$Entries", "names", "[Ljava/lang/String;") + .await?; let names_length = jvm.array_length(&names).await?; Ok(i < names_length as i32) @@ -71,11 +75,15 @@ impl ZipFileEntries { async fn next_element(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { tracing::debug!("java.util.zip.ZipFile$Entries::nextElement({this:?})"); - let i: i32 = jvm.get_field(&this, "i", "I").await?; - let names: ClassInstanceRef> = jvm.get_field(&this, "names", "[Ljava/lang/String;").await?; + let i: i32 = jvm.get_field(&this, "java/util/zip/ZipFile$Entries", "i", "I").await?; + let names: ClassInstanceRef> = jvm + .get_field(&this, "java/util/zip/ZipFile$Entries", "names", "[Ljava/lang/String;") + .await?; let name: Vec> = jvm.load_array(&names, i as _, 1).await?; - let zip_file = jvm.get_field(&this, "zipFile", "Ljava/util/zip/ZipFile;").await?; + let zip_file = jvm + .get_field(&this, "java/util/zip/ZipFile$Entries", "zipFile", "Ljava/util/zip/ZipFile;") + .await?; let entry = jvm .invoke_virtual( &zip_file, @@ -86,7 +94,7 @@ impl ZipFileEntries { ) .await?; - jvm.put_field(&mut this, "i", "I", i + 1).await?; + jvm.put_field(&mut this, "java/util/zip/ZipFile$Entries", "i", "I", i + 1).await?; Ok(entry) } diff --git a/rustjava-runtime/src/classes/org/rustjava/lang/rust_jar_class_loader.rs b/rustjava-runtime/src/classes/org/rustjava/lang/rust_jar_class_loader.rs index 3039326f..57b57465 100644 --- a/rustjava-runtime/src/classes/org/rustjava/lang/rust_jar_class_loader.rs +++ b/rustjava-runtime/src/classes/org/rustjava/lang/rust_jar_class_loader.rs @@ -50,7 +50,14 @@ impl RustJarClassLoader { .invoke_special(&this, "java/lang/ClassLoader", "", "(Ljava/lang/ClassLoader;)V", (parent,)) .await?; - jvm.put_field(&mut this, "classPaths", "[Ljava/lang/String;", class_paths).await?; + jvm.put_field( + &mut this, + "org/rustjava/lang/RustJarClassLoader", + "classPaths", + "[Ljava/lang/String;", + class_paths, + ) + .await?; Ok(()) } @@ -64,7 +71,9 @@ impl RustJarClassLoader { tracing::debug!("org.rustjava.lang.RustJarClassLoader::findClass({this:?}, {name:?})"); let name = JavaLangString::to_rust_string(jvm, &name).await?; - let class_paths = jvm.get_field(&this, "classPaths", "[Ljava/lang/String;").await?; + let class_paths = jvm + .get_field(&this, "org/rustjava/lang/RustJarClassLoader", "classPaths", "[Ljava/lang/String;") + .await?; let class_paths: Vec> = jvm.load_array(&class_paths, 0, jvm.array_length(&class_paths).await? as usize).await?; for class_path in class_paths { diff --git a/rustjava-runtime/src/classes/org/rustjava/net/file_url_connection.rs b/rustjava-runtime/src/classes/org/rustjava/net/file_url_connection.rs index 028670f8..6cc61607 100644 --- a/rustjava-runtime/src/classes/org/rustjava/net/file_url_connection.rs +++ b/rustjava-runtime/src/classes/org/rustjava/net/file_url_connection.rs @@ -48,7 +48,8 @@ impl FileURLConnection { .invoke_special(&this, "java/net/URLConnection", "", "(Ljava/net/URL;)V", (url,)) .await?; - jvm.put_field(&mut this, "file", "Ljava/io/File;", file).await?; + jvm.put_field(&mut this, "org/rustjava/net/FileURLConnection", "file", "Ljava/io/File;", file) + .await?; Ok(()) } @@ -56,7 +57,9 @@ impl FileURLConnection { async fn get_input_stream(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { tracing::debug!("org.rustjava.net.FileURLConnection::getInputStream({this:?})"); - let file: ClassInstanceRef = jvm.get_field(&this, "file", "Ljava/io/File;").await?; + let file: ClassInstanceRef = jvm + .get_field(&this, "org/rustjava/net/FileURLConnection", "file", "Ljava/io/File;") + .await?; let file_input_stream = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (file,)).await?; Ok(file_input_stream.into()) diff --git a/rustjava-runtime/tests/classes/java/io/test_buffered_reader.rs b/rustjava-runtime/tests/classes/java/io/test_buffered_reader.rs index 440a39ba..f0c1b803 100644 --- a/rustjava-runtime/tests/classes/java/io/test_buffered_reader.rs +++ b/rustjava-runtime/tests/classes/java/io/test_buffered_reader.rs @@ -50,15 +50,15 @@ impl ChunkedReader { chunk_size: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/Reader", "", "()V", ()).await?; - jvm.put_field(&mut this, "data", "[C", data).await?; - jvm.put_field(&mut this, "position", "I", 0).await?; - jvm.put_field(&mut this, "chunkSize", "I", chunk_size).await?; - let data: ClassInstanceRef> = jvm.get_field(&this, "data", "[C").await?; + jvm.put_field(&mut this, "ChunkedReader", "data", "[C", data).await?; + jvm.put_field(&mut this, "ChunkedReader", "position", "I", 0).await?; + jvm.put_field(&mut this, "ChunkedReader", "chunkSize", "I", chunk_size).await?; + let data: ClassInstanceRef> = jvm.get_field(&this, "ChunkedReader", "data", "[C").await?; let data_length = jvm.array_length(&data).await? as i32; - jvm.put_field(&mut this, "visibleLength", "I", data_length).await?; - jvm.put_field(&mut this, "zeroReads", "I", 0).await?; - jvm.put_field(&mut this, "closed", "Z", false).await?; - jvm.put_field(&mut this, "closeCount", "I", 0).await?; + jvm.put_field(&mut this, "ChunkedReader", "visibleLength", "I", data_length).await?; + jvm.put_field(&mut this, "ChunkedReader", "zeroReads", "I", 0).await?; + jvm.put_field(&mut this, "ChunkedReader", "closed", "Z", false).await?; + jvm.put_field(&mut this, "ChunkedReader", "closeCount", "I", 0).await?; Ok(()) } @@ -70,7 +70,7 @@ impl ChunkedReader { offset: i32, length: i32, ) -> Result { - if jvm.get_field::(&this, "closed", "Z").await? { + if jvm.get_field::(&this, "ChunkedReader", "closed", "Z").await? { return Err(jvm.exception("java/io/IOException", "reader is closed").await); } @@ -82,43 +82,43 @@ impl ChunkedReader { return Ok(0); } - let zero_reads: i32 = jvm.get_field(&this, "zeroReads", "I").await?; + let zero_reads: i32 = jvm.get_field(&this, "ChunkedReader", "zeroReads", "I").await?; if zero_reads > 0 { - jvm.put_field(&mut this, "zeroReads", "I", zero_reads - 1).await?; + jvm.put_field(&mut this, "ChunkedReader", "zeroReads", "I", zero_reads - 1).await?; return Ok(0); } - let data: ClassInstanceRef> = jvm.get_field(&this, "data", "[C").await?; - let position: i32 = jvm.get_field(&this, "position", "I").await?; - let visible_length: i32 = jvm.get_field(&this, "visibleLength", "I").await?; + let data: ClassInstanceRef> = jvm.get_field(&this, "ChunkedReader", "data", "[C").await?; + let position: i32 = jvm.get_field(&this, "ChunkedReader", "position", "I").await?; + let visible_length: i32 = jvm.get_field(&this, "ChunkedReader", "visibleLength", "I").await?; let available = visible_length.min(jvm.array_length(&data).await? as i32) - position; if available == 0 { return Ok(-1); } - let chunk_size: i32 = jvm.get_field(&this, "chunkSize", "I").await?; + let chunk_size: i32 = jvm.get_field(&this, "ChunkedReader", "chunkSize", "I").await?; let count = length.min(available).min(chunk_size); let values: Vec = jvm.load_array(&data, position as usize, count as usize).await?; jvm.store_array(&mut target, offset as usize, values).await?; - jvm.put_field(&mut this, "position", "I", position + count).await?; + jvm.put_field(&mut this, "ChunkedReader", "position", "I", position + count).await?; Ok(count) } async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - if jvm.get_field::(&this, "closed", "Z").await? { + if jvm.get_field::(&this, "ChunkedReader", "closed", "Z").await? { return Err(jvm.exception("java/io/IOException", "reader is closed").await); } - let data: ClassInstanceRef> = jvm.get_field(&this, "data", "[C").await?; - let position: i32 = jvm.get_field(&this, "position", "I").await?; - let visible_length: i32 = jvm.get_field(&this, "visibleLength", "I").await?; + let data: ClassInstanceRef> = jvm.get_field(&this, "ChunkedReader", "data", "[C").await?; + let position: i32 = jvm.get_field(&this, "ChunkedReader", "position", "I").await?; + let visible_length: i32 = jvm.get_field(&this, "ChunkedReader", "visibleLength", "I").await?; Ok(position < visible_length.min(jvm.array_length(&data).await? as i32)) } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let close_count: i32 = jvm.get_field(&this, "closeCount", "I").await?; - jvm.put_field(&mut this, "closeCount", "I", close_count + 1).await?; - jvm.put_field(&mut this, "closed", "Z", true).await?; + let close_count: i32 = jvm.get_field(&this, "ChunkedReader", "closeCount", "I").await?; + jvm.put_field(&mut this, "ChunkedReader", "closeCount", "I", close_count + 1).await?; + jvm.put_field(&mut this, "ChunkedReader", "closed", "Z", true).await?; Ok(()) } } @@ -147,19 +147,22 @@ impl ReadRunner { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, reader: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "reader", "Ljava/io/BufferedReader;", reader).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await?; - jvm.put_field(&mut this, "value", "I", -1).await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "reader", "Ljava/io/BufferedReader;", reader) + .await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "done", "Z", false).await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "value", "I", -1).await?; Ok(()) } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let reader: ClassInstanceRef = jvm.get_field(&this, "reader", "Ljava/io/BufferedReader;").await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "started", "Z", true).await?; + let reader: ClassInstanceRef = jvm + .get_field(&this, "BufferedReaderReadRunner", "reader", "Ljava/io/BufferedReader;") + .await?; let value: i32 = jvm.invoke_virtual(&reader, "java/io/BufferedReader", "read", "()I", ()).await?; - jvm.put_field(&mut this, "value", "I", value).await?; - jvm.put_field(&mut this, "done", "Z", true).await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "value", "I", value).await?; + jvm.put_field(&mut this, "BufferedReaderReadRunner", "done", "Z", true).await?; Ok(()) } } @@ -473,7 +476,7 @@ async fn test_buffered_reader_mark_restores_pending_crlf_state() -> Result<()> { #[tokio::test] async fn test_buffered_reader_ready_preserves_pending_lf_until_input_is_available() -> Result<()> { let (jvm, mut source, reader) = buffered_reader("\r\nX", 3, 2).await?; - jvm.put_field(&mut source, "visibleLength", "I", 1).await?; + jvm.put_field(&mut source, "ChunkedReader", "visibleLength", "I", 1).await?; let line: ClassInstanceRef = jvm .invoke_virtual(&reader, "java/io/BufferedReader", "readLine", "()Ljava/lang/String;", ()) @@ -484,7 +487,7 @@ async fn test_buffered_reader_ready_preserves_pending_lf_until_input_is_availabl .await? ); - jvm.put_field(&mut source, "visibleLength", "I", 3).await?; + jvm.put_field(&mut source, "ChunkedReader", "visibleLength", "I", 3).await?; assert_eq!( jvm.invoke_virtual::<_, i32>(&reader, "java/io/BufferedReader", "read", "()I", ()).await?, 'X' as i32 @@ -496,7 +499,7 @@ async fn test_buffered_reader_ready_preserves_pending_lf_until_input_is_availabl #[tokio::test] async fn test_buffered_reader_fill_retries_temporary_zero_read() -> Result<()> { let (jvm, mut source, reader) = buffered_reader("a", 1, 1).await?; - jvm.put_field(&mut source, "zeroReads", "I", 1).await?; + jvm.put_field(&mut source, "ChunkedReader", "zeroReads", "I", 1).await?; assert_eq!( jvm.invoke_virtual::<_, i32>(&reader, "java/io/BufferedReader", "read", "()I", ()).await?, @@ -523,21 +526,21 @@ async fn test_buffered_reader_serializes_on_inherited_reader_lock() -> Result<() let mut started = false; for _ in 0..100 { - started = jvm.get_field::(&runner, "started", "Z").await?; + started = jvm.get_field::(&runner, "BufferedReaderReadRunner", "started", "Z").await?; if started { break; } tokio::time::sleep(Duration::from_millis(1)).await; } tokio::time::sleep(Duration::from_millis(10)).await; - let completed_while_lock_was_held = jvm.get_field::(&runner, "done", "Z").await?; + let completed_while_lock_was_held = jvm.get_field::(&runner, "BufferedReaderReadRunner", "done", "Z").await?; jvm.monitor_exit(&source).await?; let _: () = jvm.invoke_virtual(&thread, &thread.class_definition().name(), "join", "()V", ()).await?; assert!(started, "worker thread did not start"); assert!(!completed_while_lock_was_held, "read did not synchronize on Reader.lock"); - assert_eq!(jvm.get_field::(&runner, "value", "I").await?, 'a' as i32); + assert_eq!(jvm.get_field::(&runner, "BufferedReaderReadRunner", "value", "I").await?, 'a' as i32); Ok(()) } @@ -548,7 +551,7 @@ async fn test_buffered_reader_close_is_idempotent_and_closes_all_operations() -> let _: () = jvm.invoke_virtual(&reader, "java/io/BufferedReader", "close", "()V", ()).await?; let _: () = jvm.invoke_virtual(&reader, "java/io/BufferedReader", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&source, "closeCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&source, "ChunkedReader", "closeCount", "I").await?, 1); assert!( jvm.invoke_virtual::<_, bool>(&reader, "java/io/BufferedReader", "markSupported", "()Z", ()) .await? diff --git a/rustjava-runtime/tests/classes/java/io/test_buffered_streams.rs b/rustjava-runtime/tests/classes/java/io/test_buffered_streams.rs index 506aa26e..29038731 100644 --- a/rustjava-runtime/tests/classes/java/io/test_buffered_streams.rs +++ b/rustjava-runtime/tests/classes/java/io/test_buffered_streams.rs @@ -190,12 +190,15 @@ async fn bio_01_bio_02_bio_03_buffered_input_stream_contract() -> Result<()> { panic!("zero skip after close must throw IOException"); }; assert!(jvm.is_instance(&*exception, "java/io/IOException")); - let position: i32 = jvm.get_field(&stream, "pos", "I").await?; + let position: i32 = jvm.get_field(&stream, "java/io/BufferedInputStream", "pos", "I").await?; let _: () = jvm .invoke_virtual(&stream, &stream.class_definition().name(), "mark", "(I)V", (17,)) .await?; - assert_eq!(jvm.get_field::(&stream, "marklimit", "I").await?, 17); - assert_eq!(jvm.get_field::(&stream, "markpos", "I").await?, position); + assert_eq!(jvm.get_field::(&stream, "java/io/BufferedInputStream", "marklimit", "I").await?, 17); + assert_eq!( + jvm.get_field::(&stream, "java/io/BufferedInputStream", "markpos", "I").await?, + position + ); let closed: Result<()> = jvm.invoke_virtual(&stream, &stream.class_definition().name(), "reset", "()V", ()).await; let Err(JavaError::JavaException(exception)) = closed else { panic!("reset after a post-close mark must still throw IOException"); @@ -368,7 +371,7 @@ async fn bio_06_bio_07_buffered_writer_contract() -> Result<()> { let writer = jvm .new_class("java/io/BufferedWriter", "(Ljava/io/Writer;I)V", (output.clone(), 4)) .await?; - let lock: ClassInstanceRef = jvm.get_field(&writer, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&writer, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; assert_eq!( lock.identity(), output.identity(), diff --git a/rustjava-runtime/tests/classes/java/io/test_file_reader_writer.rs b/rustjava-runtime/tests/classes/java/io/test_file_reader_writer.rs index 71b66725..eb7d493e 100644 --- a/rustjava-runtime/tests/classes/java/io/test_file_reader_writer.rs +++ b/rustjava-runtime/tests/classes/java/io/test_file_reader_writer.rs @@ -308,7 +308,7 @@ async fn file_01_file_reader_constructor_contracts() -> Result<()> { let input = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (file,)).await?; let descriptor: ClassInstanceRef = - jvm.get_field(&input, "fd", "Ljava/io/FileDescriptor;").await?; + jvm.get_field(&input, "java/io/FileInputStream", "fd", "Ljava/io/FileDescriptor;").await?; let reader = jvm.new_class("java/io/FileReader", "(Ljava/io/FileDescriptor;)V", (descriptor,)).await?; assert_eq!( jvm.invoke_virtual::<_, i32>(&reader, &reader.class_definition().name(), "read", "()I", ()) @@ -395,8 +395,9 @@ async fn file_02_file_03_file_writer_constructor_and_append_contracts() -> Resul assert_eq!(&*runtime.files.lock().unwrap()["output.txt"].lock().unwrap(), b"reset"); let output = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?; - let descriptor: ClassInstanceRef = - jvm.get_field(&output, "fd", "Ljava/io/FileDescriptor;").await?; + let descriptor: ClassInstanceRef = jvm + .get_field(&output, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;") + .await?; let writer = jvm.new_class("java/io/FileWriter", "(Ljava/io/FileDescriptor;)V", (descriptor,)).await?; let value = JavaLangString::from_rust_string(&jvm, "F").await?; let _: () = jvm diff --git a/rustjava-runtime/tests/classes/java/io/test_input_stream_reader.rs b/rustjava-runtime/tests/classes/java/io/test_input_stream_reader.rs index 42f2a3db..0668b673 100644 --- a/rustjava-runtime/tests/classes/java/io/test_input_stream_reader.rs +++ b/rustjava-runtime/tests/classes/java/io/test_input_stream_reader.rs @@ -32,21 +32,21 @@ impl OneByteInputStream { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, data: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/InputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "data", "[B", data).await?; - jvm.put_field(&mut this, "position", "I", 0).await?; + jvm.put_field(&mut this, "OneByteInputStream", "data", "[B", data).await?; + jvm.put_field(&mut this, "OneByteInputStream", "position", "I", 0).await?; Ok(()) } async fn read(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { - let data: ClassInstanceRef> = jvm.get_field(&this, "data", "[B").await?; - let position: i32 = jvm.get_field(&this, "position", "I").await?; + let data: ClassInstanceRef> = jvm.get_field(&this, "OneByteInputStream", "data", "[B").await?; + let position: i32 = jvm.get_field(&this, "OneByteInputStream", "position", "I").await?; if position == jvm.array_length(&data).await? as i32 { return Ok(-1); } let value = jvm.load_array::(&data, position as usize, 1).await?[0]; - jvm.put_field(&mut this, "position", "I", position + 1).await?; + jvm.put_field(&mut this, "OneByteInputStream", "position", "I", position + 1).await?; Ok(value as u8 as i32) } diff --git a/rustjava-runtime/tests/classes/java/io/test_output_stream_close.rs b/rustjava-runtime/tests/classes/java/io/test_output_stream_close.rs index 0fb2c3fb..f4d42ce2 100644 --- a/rustjava-runtime/tests/classes/java/io/test_output_stream_close.rs +++ b/rustjava-runtime/tests/classes/java/io/test_output_stream_close.rs @@ -34,22 +34,22 @@ impl CloseProbeOutputStream { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, flush_mode: i32, close_mode: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?; - jvm.put_field(&mut this, "closeMode", "I", close_mode).await?; - jvm.put_field(&mut this, "bytesWritten", "I", 0).await?; - jvm.put_field(&mut this, "flushCalls", "I", 0).await?; - jvm.put_field(&mut this, "closeCalls", "I", 0).await + jvm.put_field(&mut this, "CloseProbeOutputStream", "flushMode", "I", flush_mode).await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "closeMode", "I", close_mode).await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "bytesWritten", "I", 0).await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "flushCalls", "I", 0).await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "closeCalls", "I", 0).await } async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, _: i32) -> Result<()> { - let count: i32 = jvm.get_field(&this, "bytesWritten", "I").await?; - jvm.put_field(&mut this, "bytesWritten", "I", count + 1).await + let count: i32 = jvm.get_field(&this, "CloseProbeOutputStream", "bytesWritten", "I").await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "bytesWritten", "I", count + 1).await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let calls: i32 = jvm.get_field(&this, "flushCalls", "I").await?; - jvm.put_field(&mut this, "flushCalls", "I", calls + 1).await?; - match jvm.get_field::(&this, "flushMode", "I").await? { + let calls: i32 = jvm.get_field(&this, "CloseProbeOutputStream", "flushCalls", "I").await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "flushCalls", "I", calls + 1).await?; + match jvm.get_field::(&this, "CloseProbeOutputStream", "flushMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "flush failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "flush failed").await), _ => Ok(()), @@ -57,9 +57,9 @@ impl CloseProbeOutputStream { } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let calls: i32 = jvm.get_field(&this, "closeCalls", "I").await?; - jvm.put_field(&mut this, "closeCalls", "I", calls + 1).await?; - match jvm.get_field::(&this, "closeMode", "I").await? { + let calls: i32 = jvm.get_field(&this, "CloseProbeOutputStream", "closeCalls", "I").await?; + jvm.put_field(&mut this, "CloseProbeOutputStream", "closeCalls", "I", calls + 1).await?; + match jvm.get_field::(&this, "CloseProbeOutputStream", "closeMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "close failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "close failed").await), _ => Ok(()), @@ -98,14 +98,16 @@ impl FlushOverrideBufferedOutputStream { let _: () = jvm .invoke_special(&this, "java/io/BufferedOutputStream", "", "(Ljava/io/OutputStream;I)V", (out, size)) .await?; - jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?; - jvm.put_field(&mut this, "flushCalls", "I", 0).await + jvm.put_field(&mut this, "FlushOverrideBufferedOutputStream", "flushMode", "I", flush_mode) + .await?; + jvm.put_field(&mut this, "FlushOverrideBufferedOutputStream", "flushCalls", "I", 0).await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let calls: i32 = jvm.get_field(&this, "flushCalls", "I").await?; - jvm.put_field(&mut this, "flushCalls", "I", calls + 1).await?; - match jvm.get_field::(&this, "flushMode", "I").await? { + let calls: i32 = jvm.get_field(&this, "FlushOverrideBufferedOutputStream", "flushCalls", "I").await?; + jvm.put_field(&mut this, "FlushOverrideBufferedOutputStream", "flushCalls", "I", calls + 1) + .await?; + match jvm.get_field::(&this, "FlushOverrideBufferedOutputStream", "flushMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "override flush failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "override flush failed").await), _ => jvm.invoke_special(&this, "java/io/BufferedOutputStream", "flush", "()V", ()).await, @@ -144,7 +146,7 @@ async fn buffered_output_stream_inherited_close_dispatches_virtual_flush() -> Re .new_class("FlushOverrideBufferedOutputStream", "(Ljava/io/OutputStream;II)V", (output, 4, 0)) .await? .into(); - let buffer: ClassInstanceRef> = jvm.get_field(&stream, "buf", "[B").await?; + let buffer: ClassInstanceRef> = jvm.get_field(&stream, "FlushOverrideBufferedOutputStream", "buf", "[B").await?; let _: () = jvm .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "write", "(I)V", (7,)) @@ -153,21 +155,31 @@ async fn buffered_output_stream_inherited_close_dispatches_virtual_flush() -> Re .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ()) .await?; - assert_eq!(jvm.get_field::(&stream, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "bytesWritten", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stream, "count", "I").await?, 0); - let retained_buffer: ClassInstanceRef> = jvm.get_field(&stream, "buf", "[B").await?; + assert_eq!( + jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "flushCalls", "I") + .await?, + 1 + ); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "bytesWritten", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "flushCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "closeCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "count", "I").await?, 0); + let retained_buffer: ClassInstanceRef> = jvm.get_field(&stream, "FlushOverrideBufferedOutputStream", "buf", "[B").await?; assert_eq!(retained_buffer.identity(), buffer.identity()); - let closed_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + let closed_output: ClassInstanceRef = jvm + .get_field(&stream, "FlushOverrideBufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; assert!(closed_output.is_null()); let _: () = jvm .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ()) .await?; - assert_eq!(jvm.get_field::(&stream, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "flushCalls", "I") + .await?, + 1 + ); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "closeCalls", "I").await?, 1); Ok(()) } @@ -187,11 +199,17 @@ async fn filter_output_stream_close_preserves_failure_sequence_and_state() -> Re let _: () = jvm .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ()) .await?; - assert_eq!(jvm.get_field::(&stream, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stream, "count", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "bytesWritten", "I").await?, 0); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); - let closed_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!( + jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "flushCalls", "I") + .await?, + 1 + ); + assert_eq!(jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "count", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "bytesWritten", "I").await?, 0); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "closeCalls", "I").await?, 1); + let closed_output: ClassInstanceRef = jvm + .get_field(&stream, "FlushOverrideBufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; assert!(closed_output.is_null()); let backing: ClassInstanceRef = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 0)).await?.into(); @@ -205,8 +223,10 @@ async fn filter_output_stream_close_preserves_failure_sequence_and_state() -> Re panic!("unchecked flush failure must escape inherited close"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 0); - let closed_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "closeCalls", "I").await?, 0); + let closed_output: ClassInstanceRef = jvm + .get_field(&stream, "FlushOverrideBufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; assert!(closed_output.is_null()); let backing: ClassInstanceRef = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 1)).await?.into(); @@ -223,12 +243,18 @@ async fn filter_output_stream_close_preserves_failure_sequence_and_state() -> Re panic!("backing close failure must escape inherited close"); }; assert!(jvm.is_instance(&*exception, "java/io/IOException")); - assert_eq!(jvm.get_field::(&stream, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stream, "count", "I").await?, 0); - assert_eq!(jvm.get_field::(&backing, "bytesWritten", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "flushCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); - let closed_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!( + jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "flushCalls", "I") + .await?, + 1 + ); + assert_eq!(jvm.get_field::(&stream, "FlushOverrideBufferedOutputStream", "count", "I").await?, 0); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "bytesWritten", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "flushCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "CloseProbeOutputStream", "closeCalls", "I").await?, 1); + let closed_output: ClassInstanceRef = jvm + .get_field(&stream, "FlushOverrideBufferedOutputStream", "out", "Ljava/io/OutputStream;") + .await?; assert!(closed_output.is_null()); Ok(()) diff --git a/rustjava-runtime/tests/classes/java/io/test_print_stream.rs b/rustjava-runtime/tests/classes/java/io/test_print_stream.rs index c496a0e5..564efe54 100644 --- a/rustjava-runtime/tests/classes/java/io/test_print_stream.rs +++ b/rustjava-runtime/tests/classes/java/io/test_print_stream.rs @@ -56,55 +56,58 @@ impl ProbeOutputStream { ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "", "()V", ()).await?; let content = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?; - jvm.put_field(&mut this, "content", "Ljava/io/ByteArrayOutputStream;", content).await?; - jvm.put_field(&mut this, "writeMode", "I", write_mode).await?; - jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?; - jvm.put_field(&mut this, "closeMode", "I", close_mode).await?; - jvm.put_field(&mut this, "writeCount", "I", 0).await?; - jvm.put_field(&mut this, "flushCount", "I", 0).await?; - jvm.put_field(&mut this, "closeCount", "I", 0).await?; - jvm.put_field(&mut this, "blockFirstWrite", "Z", false).await?; - jvm.put_field(&mut this, "firstWriteEntered", "Z", false).await?; - jvm.put_field(&mut this, "releaseFirstWrite", "Z", false).await?; - jvm.put_field(&mut this, "blockFirstClose", "Z", false).await?; - jvm.put_field(&mut this, "firstCloseEntered", "Z", false).await?; - jvm.put_field(&mut this, "releaseFirstClose", "Z", false).await + jvm.put_field(&mut this, "ProbeOutputStream", "content", "Ljava/io/ByteArrayOutputStream;", content) + .await?; + jvm.put_field(&mut this, "ProbeOutputStream", "writeMode", "I", write_mode).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "flushMode", "I", flush_mode).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "closeMode", "I", close_mode).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "writeCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "flushCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "closeCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "blockFirstWrite", "Z", false).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "firstWriteEntered", "Z", false).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "releaseFirstWrite", "Z", false).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "blockFirstClose", "Z", false).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "firstCloseEntered", "Z", false).await?; + jvm.put_field(&mut this, "ProbeOutputStream", "releaseFirstClose", "Z", false).await } async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { - let count: i32 = jvm.get_field(&this, "writeCount", "I").await?; - jvm.put_field(&mut this, "writeCount", "I", count + 1).await?; - match jvm.get_field::(&this, "writeMode", "I").await? { + let count: i32 = jvm.get_field(&this, "ProbeOutputStream", "writeCount", "I").await?; + jvm.put_field(&mut this, "ProbeOutputStream", "writeCount", "I", count + 1).await?; + match jvm.get_field::(&this, "ProbeOutputStream", "writeMode", "I").await? { 1 => return Err(jvm.exception("java/io/IOException", "write failed").await), 2 => return Err(jvm.exception("java/lang/IllegalStateException", "write failed").await), 3 if count == 0 => return Err(jvm.exception("java/io/IOException", "first write failed").await), 4 if count == 1 => return Err(jvm.exception("java/io/IOException", "second write failed").await), _ => {} } - if count == 0 && jvm.get_field::(&this, "blockFirstWrite", "Z").await? { - jvm.put_field(&mut this, "firstWriteEntered", "Z", true).await?; + if count == 0 && jvm.get_field::(&this, "ProbeOutputStream", "blockFirstWrite", "Z").await? { + jvm.put_field(&mut this, "ProbeOutputStream", "firstWriteEntered", "Z", true).await?; for _ in 0..1000 { - if jvm.get_field::(&this, "releaseFirstWrite", "Z").await? { + if jvm.get_field::(&this, "ProbeOutputStream", "releaseFirstWrite", "Z").await? { break; } tokio::time::sleep(Duration::from_millis(1)).await; } - if !jvm.get_field::(&this, "releaseFirstWrite", "Z").await? { + if !jvm.get_field::(&this, "ProbeOutputStream", "releaseFirstWrite", "Z").await? { return Err(jvm .exception("java/lang/IllegalStateException", "timed out waiting for write release") .await); } } - let content: ClassInstanceRef = jvm.get_field(&this, "content", "Ljava/io/ByteArrayOutputStream;").await?; + let content: ClassInstanceRef = jvm + .get_field(&this, "ProbeOutputStream", "content", "Ljava/io/ByteArrayOutputStream;") + .await?; jvm.invoke_virtual(&content, "java/io/ByteArrayOutputStream", "write", "(I)V", (value,)) .await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let count: i32 = jvm.get_field(&this, "flushCount", "I").await?; - jvm.put_field(&mut this, "flushCount", "I", count + 1).await?; - match jvm.get_field::(&this, "flushMode", "I").await? { + let count: i32 = jvm.get_field(&this, "ProbeOutputStream", "flushCount", "I").await?; + jvm.put_field(&mut this, "ProbeOutputStream", "flushCount", "I", count + 1).await?; + match jvm.get_field::(&this, "ProbeOutputStream", "flushMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "flush failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "flush failed").await), 3 if count == 2 => Err(jvm.exception("java/io/IOException", "third flush failed").await), @@ -113,23 +116,23 @@ impl ProbeOutputStream { } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let count: i32 = jvm.get_field(&this, "closeCount", "I").await?; - jvm.put_field(&mut this, "closeCount", "I", count + 1).await?; - if count == 0 && jvm.get_field::(&this, "blockFirstClose", "Z").await? { - jvm.put_field(&mut this, "firstCloseEntered", "Z", true).await?; + let count: i32 = jvm.get_field(&this, "ProbeOutputStream", "closeCount", "I").await?; + jvm.put_field(&mut this, "ProbeOutputStream", "closeCount", "I", count + 1).await?; + if count == 0 && jvm.get_field::(&this, "ProbeOutputStream", "blockFirstClose", "Z").await? { + jvm.put_field(&mut this, "ProbeOutputStream", "firstCloseEntered", "Z", true).await?; for _ in 0..1000 { - if jvm.get_field::(&this, "releaseFirstClose", "Z").await? { + if jvm.get_field::(&this, "ProbeOutputStream", "releaseFirstClose", "Z").await? { break; } tokio::time::sleep(Duration::from_millis(1)).await; } - if !jvm.get_field::(&this, "releaseFirstClose", "Z").await? { + if !jvm.get_field::(&this, "ProbeOutputStream", "releaseFirstClose", "Z").await? { return Err(jvm .exception("java/lang/IllegalStateException", "timed out waiting for close release") .await); } } - match jvm.get_field::(&this, "closeMode", "I").await? { + match jvm.get_field::(&this, "ProbeOutputStream", "closeMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "close failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "close failed").await), _ => Ok(()), @@ -164,22 +167,22 @@ impl OverridePrintStream { let _: () = jvm .invoke_special(&this, "java/io/PrintStream", "", "(Ljava/io/OutputStream;)V", (out,)) .await?; - jvm.put_field(&mut this, "printCount", "I", 0).await?; - jvm.put_field(&mut this, "printlnCount", "I", 0).await?; - jvm.put_field(&mut this, "writeCount", "I", 0).await + jvm.put_field(&mut this, "OverridePrintStream", "printCount", "I", 0).await?; + jvm.put_field(&mut this, "OverridePrintStream", "printlnCount", "I", 0).await?; + jvm.put_field(&mut this, "OverridePrintStream", "writeCount", "I", 0).await } async fn print_int(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32) -> Result<()> { - let count: i32 = jvm.get_field(&this, "printCount", "I").await?; - jvm.put_field(&mut this, "printCount", "I", count + 1).await?; + let count: i32 = jvm.get_field(&this, "OverridePrintStream", "printCount", "I").await?; + jvm.put_field(&mut this, "OverridePrintStream", "printCount", "I", count + 1).await?; let value = JavaLangString::from_rust_string(jvm, &format!("<{value}>")).await?; jvm.invoke_special(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,)) .await } async fn println(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let count: i32 = jvm.get_field(&this, "printlnCount", "I").await?; - jvm.put_field(&mut this, "printlnCount", "I", count + 1).await + let count: i32 = jvm.get_field(&this, "OverridePrintStream", "printlnCount", "I").await?; + jvm.put_field(&mut this, "OverridePrintStream", "printlnCount", "I", count + 1).await } async fn write( @@ -190,8 +193,8 @@ impl OverridePrintStream { offset: i32, length: i32, ) -> Result<()> { - let count: i32 = jvm.get_field(&this, "writeCount", "I").await?; - jvm.put_field(&mut this, "writeCount", "I", count + 1).await?; + let count: i32 = jvm.get_field(&this, "OverridePrintStream", "writeCount", "I").await?; + jvm.put_field(&mut this, "OverridePrintStream", "writeCount", "I", count + 1).await?; jvm.invoke_special(&this, "java/io/PrintStream", "write", "([BII)V", (bytes, offset, length)) .await } @@ -227,18 +230,19 @@ impl PrintStreamRunner { value: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "stream", "Ljava/io/PrintStream;", stream).await?; - jvm.put_field(&mut this, "value", "I", value).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await + jvm.put_field(&mut this, "PrintStreamRunner", "stream", "Ljava/io/PrintStream;", stream) + .await?; + jvm.put_field(&mut this, "PrintStreamRunner", "value", "I", value).await?; + jvm.put_field(&mut this, "PrintStreamRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "PrintStreamRunner", "done", "Z", false).await } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let stream: ClassInstanceRef = jvm.get_field(&this, "stream", "Ljava/io/PrintStream;").await?; - let value: i32 = jvm.get_field(&this, "value", "I").await?; + jvm.put_field(&mut this, "PrintStreamRunner", "started", "Z", true).await?; + let stream: ClassInstanceRef = jvm.get_field(&this, "PrintStreamRunner", "stream", "Ljava/io/PrintStream;").await?; + let value: i32 = jvm.get_field(&this, "PrintStreamRunner", "value", "I").await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "(I)V", (value,)).await?; - jvm.put_field(&mut this, "done", "Z", true).await + jvm.put_field(&mut this, "PrintStreamRunner", "done", "Z", true).await } } @@ -265,16 +269,17 @@ impl PrintStreamCloseRunner { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, stream: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "stream", "Ljava/io/PrintStream;", stream).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await + jvm.put_field(&mut this, "PrintStreamCloseRunner", "stream", "Ljava/io/PrintStream;", stream) + .await?; + jvm.put_field(&mut this, "PrintStreamCloseRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "PrintStreamCloseRunner", "done", "Z", false).await } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let stream: ClassInstanceRef = jvm.get_field(&this, "stream", "Ljava/io/PrintStream;").await?; + jvm.put_field(&mut this, "PrintStreamCloseRunner", "started", "Z", true).await?; + let stream: ClassInstanceRef = jvm.get_field(&this, "PrintStreamCloseRunner", "stream", "Ljava/io/PrintStream;").await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "close", "()V", ()).await?; - jvm.put_field(&mut this, "done", "Z", true).await + jvm.put_field(&mut this, "PrintStreamCloseRunner", "done", "Z", true).await } } @@ -383,13 +388,15 @@ async fn ps_01_constructor_state_descriptors_and_access_flags() -> Result<()> { let default_stream = jvm .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (output.clone(),)) .await?; - assert!(!jvm.get_field::(&default_stream, "autoFlush", "Z").await?); - assert!(!jvm.get_field::(&default_stream, "trouble", "Z").await?); - assert!(!jvm.get_field::(&default_stream, "closing", "Z").await?); - let char_out: ClassInstanceRef = jvm.get_field(&default_stream, "charOut", "Ljava/io/OutputStreamWriter;").await?; + assert!(!jvm.get_field::(&default_stream, "java/io/PrintStream", "autoFlush", "Z").await?); + assert!(!jvm.get_field::(&default_stream, "java/io/PrintStream", "trouble", "Z").await?); + assert!(!jvm.get_field::(&default_stream, "java/io/PrintStream", "closing", "Z").await?); + let char_out: ClassInstanceRef = jvm + .get_field(&default_stream, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; assert!(!char_out.is_null()); let configured_stream = jvm.new_class("java/io/PrintStream", "(Ljava/io/OutputStream;Z)V", (output, true)).await?; - assert!(jvm.get_field::(&configured_stream, "autoFlush", "Z").await?); + assert!(jvm.get_field::(&configured_stream, "java/io/PrintStream", "autoFlush", "Z").await?); for descriptor in ["(Ljava/io/OutputStream;)V", "(Ljava/io/OutputStream;Z)V"] { let null_output: ClassInstanceRef = None.into(); @@ -416,7 +423,7 @@ async fn ps_02_auto_flush_matches_public_write_and_println_contracts() -> Result .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "write", "(I)V", ('x' as i32,)).await?; - assert_eq!(jvm.get_field::(&output, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await?, 0); let formatted_output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; let formatted_stream = jvm @@ -435,21 +442,21 @@ async fn ps_02_auto_flush_matches_public_write_and_println_contracts() -> Result (format, arguments), ) .await?; - let format_writes: i32 = jvm.get_field(&formatted_output, "writeCount", "I").await?; + let format_writes: i32 = jvm.get_field(&formatted_output, "ProbeOutputStream", "writeCount", "I").await?; assert!(format_writes > 0); - assert_eq!(jvm.get_field::(&formatted_output, "flushCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&formatted_output, "ProbeOutputStream", "flushCount", "I").await?, 1); let _: () = jvm .invoke_virtual(&stream, "java/io/PrintStream", "write", "(I)V", ('\n' as i32,)) .await?; - assert_eq!(jvm.get_field::(&output, "flushCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await?, 1); let mut bytes = jvm.instantiate_array("B", 2).await?; jvm.store_array(&mut bytes, 0, [b'a' as i8, b'b' as i8]).await?; let _: () = jvm .invoke_virtual(&stream, "java/io/PrintStream", "write", "([BII)V", (bytes, 0, 2)) .await?; - assert_eq!(jvm.get_field::(&output, "flushCount", "I").await?, 2); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await?, 2); let text = JavaLangString::from_rust_string(&jvm, "s").await?; let object: ClassInstanceRef = text.clone().into(); @@ -473,7 +480,7 @@ async fn ps_02_auto_flush_matches_public_write_and_println_contracts() -> Result let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "(Z)V", (true,)).await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "(F)V", (1.5f32,)).await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "(D)V", (2.5f64,)).await?; - assert!(jvm.get_field::(&output, "flushCount", "I").await? >= 14); + assert!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await? >= 14); let output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; let stream = jvm @@ -488,12 +495,12 @@ async fn ps_02_auto_flush_matches_public_write_and_println_contracts() -> Result .invoke_virtual(&stream, "java/io/PrintStream", "write", "([BII)V", (bytes, 0, 1)) .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "()V", ()).await?; - assert_eq!(jvm.get_field::(&output, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await?, 0); assert!( !jvm.invoke_virtual::<_, bool>(&stream, "java/io/PrintStream", "checkError", "()Z", ()) .await? ); - assert_eq!(jvm.get_field::(&output, "flushCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "flushCount", "I").await?, 1); Ok(()) } @@ -584,9 +591,9 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul .new_class("OverridePrintStream", "(Ljava/io/OutputStream;)V", (output.clone(),)) .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "println", "(I)V", (7,)).await?; - assert_eq!(jvm.get_field::(&stream, "printCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&stream, "printlnCount", "I").await?, 0); - assert!(jvm.get_field::(&stream, "writeCount", "I").await? >= 2); + assert_eq!(jvm.get_field::(&stream, "OverridePrintStream", "printCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&stream, "OverridePrintStream", "printlnCount", "I").await?, 0); + assert!(jvm.get_field::(&stream, "OverridePrintStream", "writeCount", "I").await? >= 2); let bytes: ClassInstanceRef> = jvm .invoke_virtual(&output, "java/io/ByteArrayOutputStream", "toByteArray", "()[B", ()) .await?; @@ -596,7 +603,8 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul ); let mut blocking_output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; - jvm.put_field(&mut blocking_output, "blockFirstWrite", "Z", true).await?; + jvm.put_field(&mut blocking_output, "ProbeOutputStream", "blockFirstWrite", "Z", true) + .await?; let stream: ClassInstanceRef = jvm .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (blocking_output.clone(),)) .await? @@ -619,7 +627,9 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul .await?; let mut first_write_entered = false; for _ in 0..1000 { - first_write_entered = jvm.get_field::(&blocking_output, "firstWriteEntered", "Z").await?; + first_write_entered = jvm + .get_field::(&blocking_output, "ProbeOutputStream", "firstWriteEntered", "Z") + .await?; if first_write_entered { break; } @@ -632,7 +642,7 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul .await?; let mut second_started = false; for _ in 0..1000 { - second_started = jvm.get_field::(&second_runner, "started", "Z").await?; + second_started = jvm.get_field::(&second_runner, "PrintStreamRunner", "started", "Z").await?; if second_started { break; } @@ -640,17 +650,20 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul } tokio::time::sleep(Duration::from_millis(10)).await; assert!(second_started, "second println worker did not start"); - assert_eq!(jvm.get_field::(&blocking_output, "writeCount", "I").await?, 1); - assert!(!jvm.get_field::(&second_runner, "done", "Z").await?); + assert_eq!(jvm.get_field::(&blocking_output, "ProbeOutputStream", "writeCount", "I").await?, 1); + assert!(!jvm.get_field::(&second_runner, "PrintStreamRunner", "done", "Z").await?); - jvm.put_field(&mut blocking_output, "releaseFirstWrite", "Z", true).await?; + jvm.put_field(&mut blocking_output, "ProbeOutputStream", "releaseFirstWrite", "Z", true) + .await?; let _: () = jvm .invoke_virtual(&first_thread, &first_thread.class_definition().name(), "join", "()V", ()) .await?; let _: () = jvm .invoke_virtual(&second_thread, &second_thread.class_definition().name(), "join", "()V", ()) .await?; - let content: ClassInstanceRef = jvm.get_field(&blocking_output, "content", "Ljava/io/ByteArrayOutputStream;").await?; + let content: ClassInstanceRef = jvm + .get_field(&blocking_output, "ProbeOutputStream", "content", "Ljava/io/ByteArrayOutputStream;") + .await?; let bytes: ClassInstanceRef> = jvm .invoke_virtual(&content, "java/io/ByteArrayOutputStream", "toByteArray", "()[B", ()) .await?; @@ -666,7 +679,7 @@ async fn ps_02_typed_println_is_atomic_and_preserves_virtual_dispatch() -> Resul async fn ps_02_write_and_close_are_serialized_on_the_stream_monitor() -> Result<()> { let jvm = probe_jvm().await?; let mut output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; - jvm.put_field(&mut output, "blockFirstWrite", "Z", true).await?; + jvm.put_field(&mut output, "ProbeOutputStream", "blockFirstWrite", "Z", true).await?; let stream: ClassInstanceRef = jvm .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (output.clone(),)) .await? @@ -685,7 +698,7 @@ async fn ps_02_write_and_close_are_serialized_on_the_stream_monitor() -> Result< .await?; let mut first_write_entered = false; for _ in 0..1000 { - first_write_entered = jvm.get_field::(&output, "firstWriteEntered", "Z").await?; + first_write_entered = jvm.get_field::(&output, "ProbeOutputStream", "firstWriteEntered", "Z").await?; if first_write_entered { break; } @@ -698,7 +711,7 @@ async fn ps_02_write_and_close_are_serialized_on_the_stream_monitor() -> Result< .await?; let mut close_started = false; for _ in 0..1000 { - close_started = jvm.get_field::(&closer, "started", "Z").await?; + close_started = jvm.get_field::(&closer, "PrintStreamCloseRunner", "started", "Z").await?; if close_started { break; } @@ -706,18 +719,20 @@ async fn ps_02_write_and_close_are_serialized_on_the_stream_monitor() -> Result< } tokio::time::sleep(Duration::from_millis(10)).await; assert!(close_started); - assert_eq!(jvm.get_field::(&output, "closeCount", "I").await?, 0); - assert!(!jvm.get_field::(&closer, "done", "Z").await?); + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "closeCount", "I").await?, 0); + assert!(!jvm.get_field::(&closer, "PrintStreamCloseRunner", "done", "Z").await?); - jvm.put_field(&mut output, "releaseFirstWrite", "Z", true).await?; + jvm.put_field(&mut output, "ProbeOutputStream", "releaseFirstWrite", "Z", true).await?; let _: () = jvm .invoke_virtual(&writer_thread, &writer_thread.class_definition().name(), "join", "()V", ()) .await?; let _: () = jvm .invoke_virtual(&close_thread, &close_thread.class_definition().name(), "join", "()V", ()) .await?; - assert_eq!(jvm.get_field::(&output, "closeCount", "I").await?, 1); - let content: ClassInstanceRef = jvm.get_field(&output, "content", "Ljava/io/ByteArrayOutputStream;").await?; + assert_eq!(jvm.get_field::(&output, "ProbeOutputStream", "closeCount", "I").await?, 1); + let content: ClassInstanceRef = jvm + .get_field(&output, "ProbeOutputStream", "content", "Ljava/io/ByteArrayOutputStream;") + .await?; let bytes: ClassInstanceRef> = jvm .invoke_virtual(&content, "java/io/ByteArrayOutputStream", "toByteArray", "()[B", ()) .await?; @@ -742,8 +757,10 @@ async fn ps_02_failure_phases_continue_like_jdk_and_nested_error_is_visible() -> let _: () = jvm .invoke_virtual(&stream, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", (value,)) .await?; - assert_eq!(jvm.get_field::(&value_failure, "writeCount", "I").await?, 2); - let content: ClassInstanceRef = jvm.get_field(&value_failure, "content", "Ljava/io/ByteArrayOutputStream;").await?; + assert_eq!(jvm.get_field::(&value_failure, "ProbeOutputStream", "writeCount", "I").await?, 2); + let content: ClassInstanceRef = jvm + .get_field(&value_failure, "ProbeOutputStream", "content", "Ljava/io/ByteArrayOutputStream;") + .await?; let bytes: ClassInstanceRef> = jvm .invoke_virtual(&content, "java/io/ByteArrayOutputStream", "toByteArray", "()[B", ()) .await?; @@ -763,8 +780,8 @@ async fn ps_02_failure_phases_continue_like_jdk_and_nested_error_is_visible() -> let _: () = jvm .invoke_virtual(&stream, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", (value,)) .await?; - assert_eq!(jvm.get_field::(&newline_failure, "writeCount", "I").await?, 2); - assert_eq!(jvm.get_field::(&newline_failure, "flushCount", "I").await?, 2); + assert_eq!(jvm.get_field::(&newline_failure, "ProbeOutputStream", "writeCount", "I").await?, 2); + assert_eq!(jvm.get_field::(&newline_failure, "ProbeOutputStream", "flushCount", "I").await?, 2); assert!( jvm.invoke_virtual::<_, bool>(&stream, "java/io/PrintStream", "checkError", "()Z", ()) .await? @@ -779,8 +796,11 @@ async fn ps_02_failure_phases_continue_like_jdk_and_nested_error_is_visible() -> let _: () = jvm .invoke_virtual(&stream, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", (value,)) .await?; - assert_eq!(jvm.get_field::(&final_flush_failure, "flushCount", "I").await?, 3); - assert!(jvm.get_field::(&stream, "trouble", "Z").await?); + assert_eq!( + jvm.get_field::(&final_flush_failure, "ProbeOutputStream", "flushCount", "I").await?, + 3 + ); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); let nested_failure = jvm.new_class("ProbeOutputStream", "(III)V", (0, 1, 0)).await?; let inner: ClassInstanceRef = jvm @@ -803,7 +823,7 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { let io_failure = jvm.new_class("ProbeOutputStream", "(III)V", (1, 0, 0)).await?; let stream = jvm.new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (io_failure,)).await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "write", "(I)V", (1,)).await?; - assert!(jvm.get_field::(&stream, "trouble", "Z").await?); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); let stream: ClassInstanceRef = stream.into(); assert_monitor_released(&jvm, &stream).await?; @@ -817,7 +837,7 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { panic!("non-IOException from write must propagate"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert!(!jvm.get_field::(&stream, "trouble", "Z").await?); + assert!(!jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); assert_monitor_released(&jvm, &stream).await?; let clean_output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; @@ -838,14 +858,14 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { panic!("invalid byte range must throw IndexOutOfBoundsException"); }; assert!(jvm.is_instance(&*exception, "java/lang/IndexOutOfBoundsException")); - assert!(!jvm.get_field::(&stream, "trouble", "Z").await?); + assert!(!jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); let flush_failure = jvm.new_class("ProbeOutputStream", "(III)V", (0, 1, 0)).await?; let stream = jvm .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (flush_failure,)) .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "flush", "()V", ()).await?; - assert!(jvm.get_field::(&stream, "trouble", "Z").await?); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); let runtime_flush_failure = jvm.new_class("ProbeOutputStream", "(III)V", (0, 2, 0)).await?; let stream: ClassInstanceRef = jvm @@ -872,12 +892,14 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { .into(); let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "close", "()V", ()).await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&close_failure, "closeCount", "I").await?, 1); - assert!(jvm.get_field::(&stream, "trouble", "Z").await?); - assert!(jvm.get_field::(&stream, "closing", "Z").await?); - let closed_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!(jvm.get_field::(&close_failure, "ProbeOutputStream", "closeCount", "I").await?, 1); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "closing", "Z").await?); + let closed_output: ClassInstanceRef = jvm.get_field(&stream, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; assert!(closed_output.is_null()); - let closed_writer: ClassInstanceRef = jvm.get_field(&stream, "charOut", "Ljava/io/OutputStreamWriter;").await?; + let closed_writer: ClassInstanceRef = jvm + .get_field(&stream, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; assert!(closed_writer.is_null()); assert_monitor_released(&jvm, &stream).await?; @@ -891,18 +913,29 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { panic!("non-IOException from close must propagate"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&runtime_close_failure, "closeCount", "I").await?, 1); - let stored_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!( + jvm.get_field::(&runtime_close_failure, "ProbeOutputStream", "closeCount", "I") + .await?, + 1 + ); + let stored_output: ClassInstanceRef = jvm.get_field(&stream, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; assert_eq!(stored_output.identity(), runtime_close_failure.identity()); - let stored_writer: ClassInstanceRef = jvm.get_field(&stream, "charOut", "Ljava/io/OutputStreamWriter;").await?; + let stored_writer: ClassInstanceRef = jvm + .get_field(&stream, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;") + .await?; assert!(!stored_writer.is_null()); - assert!(jvm.get_field::(&stream, "closing", "Z").await?); - assert!(!jvm.get_field::(&stream, "trouble", "Z").await?); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "closing", "Z").await?); + assert!(!jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); assert_monitor_released(&jvm, &stream).await?; - jvm.put_field(&mut runtime_close_failure, "closeMode", "I", 0).await?; + jvm.put_field(&mut runtime_close_failure, "ProbeOutputStream", "closeMode", "I", 0) + .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&runtime_close_failure, "closeCount", "I").await?, 1); - let stored_output: ClassInstanceRef = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?; + assert_eq!( + jvm.get_field::(&runtime_close_failure, "ProbeOutputStream", "closeCount", "I") + .await?, + 1 + ); + let stored_output: ClassInstanceRef = jvm.get_field(&stream, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?; assert_eq!(stored_output.identity(), runtime_close_failure.identity()); assert_monitor_released(&jvm, &stream).await?; @@ -919,15 +952,32 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { panic!("non-IOException from encoder close must propagate"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&encoder_close_failure, "writeCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&encoder_close_failure, "closeCount", "I").await?, 0); - assert!(jvm.get_field::(&stream, "closing", "Z").await?); - assert!(!jvm.get_field::(&stream, "trouble", "Z").await?); + assert_eq!( + jvm.get_field::(&encoder_close_failure, "ProbeOutputStream", "writeCount", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&encoder_close_failure, "ProbeOutputStream", "closeCount", "I") + .await?, + 0 + ); + assert!(jvm.get_field::(&stream, "java/io/PrintStream", "closing", "Z").await?); + assert!(!jvm.get_field::(&stream, "java/io/PrintStream", "trouble", "Z").await?); assert_monitor_released(&jvm, &stream).await?; - jvm.put_field(&mut encoder_close_failure, "writeMode", "I", 0).await?; + jvm.put_field(&mut encoder_close_failure, "ProbeOutputStream", "writeMode", "I", 0) + .await?; let _: () = jvm.invoke_virtual(&stream, "java/io/PrintStream", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&encoder_close_failure, "writeCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&encoder_close_failure, "closeCount", "I").await?, 0); + assert_eq!( + jvm.get_field::(&encoder_close_failure, "ProbeOutputStream", "writeCount", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&encoder_close_failure, "ProbeOutputStream", "closeCount", "I") + .await?, + 0 + ); assert_monitor_released(&jvm, &stream).await?; let closed_output = jvm.new_class("ProbeOutputStream", "(III)V", (0, 0, 0)).await?; @@ -944,7 +994,7 @@ async fn ps_02_suppresses_only_ioexception_and_closes_once() -> Result<()> { jvm.invoke_virtual::<_, bool>(&stream, "java/io/PrintStream", "checkError", "()Z", ()) .await? ); - assert_eq!(jvm.get_field::(&closed_output, "writeCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&closed_output, "ProbeOutputStream", "writeCount", "I").await?, 0); Ok(()) } diff --git a/rustjava-runtime/tests/classes/java/io/test_print_writer.rs b/rustjava-runtime/tests/classes/java/io/test_print_writer.rs index 004532aa..02aabbb5 100644 --- a/rustjava-runtime/tests/classes/java/io/test_print_writer.rs +++ b/rustjava-runtime/tests/classes/java/io/test_print_writer.rs @@ -58,19 +58,20 @@ impl ProbeWriter { ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/Writer", "", "()V", ()).await?; let content = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?; - jvm.put_field(&mut this, "content", "Ljava/lang/StringBuffer;", content).await?; - jvm.put_field(&mut this, "writeMode", "I", write_mode).await?; - jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?; - jvm.put_field(&mut this, "closeMode", "I", close_mode).await?; - jvm.put_field(&mut this, "writeCount", "I", 0).await?; - jvm.put_field(&mut this, "flushCount", "I", 0).await?; - jvm.put_field(&mut this, "closeCount", "I", 0).await?; - jvm.put_field(&mut this, "blockFirstWrite", "Z", false).await?; - jvm.put_field(&mut this, "firstWriteEntered", "Z", false).await?; - jvm.put_field(&mut this, "releaseFirstWrite", "Z", false).await?; - jvm.put_field(&mut this, "blockFirstClose", "Z", false).await?; - jvm.put_field(&mut this, "firstCloseEntered", "Z", false).await?; - jvm.put_field(&mut this, "releaseFirstClose", "Z", false).await + jvm.put_field(&mut this, "ProbeWriter", "content", "Ljava/lang/StringBuffer;", content) + .await?; + jvm.put_field(&mut this, "ProbeWriter", "writeMode", "I", write_mode).await?; + jvm.put_field(&mut this, "ProbeWriter", "flushMode", "I", flush_mode).await?; + jvm.put_field(&mut this, "ProbeWriter", "closeMode", "I", close_mode).await?; + jvm.put_field(&mut this, "ProbeWriter", "writeCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeWriter", "flushCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeWriter", "closeCount", "I", 0).await?; + jvm.put_field(&mut this, "ProbeWriter", "blockFirstWrite", "Z", false).await?; + jvm.put_field(&mut this, "ProbeWriter", "firstWriteEntered", "Z", false).await?; + jvm.put_field(&mut this, "ProbeWriter", "releaseFirstWrite", "Z", false).await?; + jvm.put_field(&mut this, "ProbeWriter", "blockFirstClose", "Z", false).await?; + jvm.put_field(&mut this, "ProbeWriter", "firstCloseEntered", "Z", false).await?; + jvm.put_field(&mut this, "ProbeWriter", "releaseFirstClose", "Z", false).await } async fn write( @@ -81,29 +82,29 @@ impl ProbeWriter { offset: i32, length: i32, ) -> Result<()> { - let write_count: i32 = jvm.get_field(&this, "writeCount", "I").await?; - jvm.put_field(&mut this, "writeCount", "I", write_count + 1).await?; - match jvm.get_field::(&this, "writeMode", "I").await? { + let write_count: i32 = jvm.get_field(&this, "ProbeWriter", "writeCount", "I").await?; + jvm.put_field(&mut this, "ProbeWriter", "writeCount", "I", write_count + 1).await?; + match jvm.get_field::(&this, "ProbeWriter", "writeMode", "I").await? { 1 => return Err(jvm.exception("java/io/IOException", "write failed").await), 2 => return Err(jvm.exception("java/lang/IllegalStateException", "write failed").await), _ => {} } - if write_count == 0 && jvm.get_field::(&this, "blockFirstWrite", "Z").await? { - jvm.put_field(&mut this, "firstWriteEntered", "Z", true).await?; + if write_count == 0 && jvm.get_field::(&this, "ProbeWriter", "blockFirstWrite", "Z").await? { + jvm.put_field(&mut this, "ProbeWriter", "firstWriteEntered", "Z", true).await?; for _ in 0..1000 { - if jvm.get_field::(&this, "releaseFirstWrite", "Z").await? { + if jvm.get_field::(&this, "ProbeWriter", "releaseFirstWrite", "Z").await? { break; } tokio::time::sleep(Duration::from_millis(1)).await; } - if !jvm.get_field::(&this, "releaseFirstWrite", "Z").await? { + if !jvm.get_field::(&this, "ProbeWriter", "releaseFirstWrite", "Z").await? { return Err(jvm .exception("java/lang/IllegalStateException", "timed out waiting for write release") .await); } } - let content: ClassInstanceRef = jvm.get_field(&this, "content", "Ljava/lang/StringBuffer;").await?; + let content: ClassInstanceRef = jvm.get_field(&this, "ProbeWriter", "content", "Ljava/lang/StringBuffer;").await?; let _: ClassInstanceRef = jvm .invoke_virtual( &content, @@ -117,9 +118,9 @@ impl ProbeWriter { } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let flush_count: i32 = jvm.get_field(&this, "flushCount", "I").await?; - jvm.put_field(&mut this, "flushCount", "I", flush_count + 1).await?; - match jvm.get_field::(&this, "flushMode", "I").await? { + let flush_count: i32 = jvm.get_field(&this, "ProbeWriter", "flushCount", "I").await?; + jvm.put_field(&mut this, "ProbeWriter", "flushCount", "I", flush_count + 1).await?; + match jvm.get_field::(&this, "ProbeWriter", "flushMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "flush failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "flush failed").await), _ => Ok(()), @@ -127,23 +128,23 @@ impl ProbeWriter { } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - let close_count: i32 = jvm.get_field(&this, "closeCount", "I").await?; - jvm.put_field(&mut this, "closeCount", "I", close_count + 1).await?; - if close_count == 0 && jvm.get_field::(&this, "blockFirstClose", "Z").await? { - jvm.put_field(&mut this, "firstCloseEntered", "Z", true).await?; + let close_count: i32 = jvm.get_field(&this, "ProbeWriter", "closeCount", "I").await?; + jvm.put_field(&mut this, "ProbeWriter", "closeCount", "I", close_count + 1).await?; + if close_count == 0 && jvm.get_field::(&this, "ProbeWriter", "blockFirstClose", "Z").await? { + jvm.put_field(&mut this, "ProbeWriter", "firstCloseEntered", "Z", true).await?; for _ in 0..1000 { - if jvm.get_field::(&this, "releaseFirstClose", "Z").await? { + if jvm.get_field::(&this, "ProbeWriter", "releaseFirstClose", "Z").await? { break; } tokio::time::sleep(Duration::from_millis(1)).await; } - if !jvm.get_field::(&this, "releaseFirstClose", "Z").await? { + if !jvm.get_field::(&this, "ProbeWriter", "releaseFirstClose", "Z").await? { return Err(jvm .exception("java/lang/IllegalStateException", "timed out waiting for close release") .await); } } - match jvm.get_field::(&this, "closeMode", "I").await? { + match jvm.get_field::(&this, "ProbeWriter", "closeMode", "I").await? { 1 => Err(jvm.exception("java/io/IOException", "close failed").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "close failed").await), _ => Ok(()), @@ -217,18 +218,19 @@ impl PrintWriterRunner { value: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "writer", "Ljava/io/PrintWriter;", writer).await?; - jvm.put_field(&mut this, "value", "I", value).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await + jvm.put_field(&mut this, "PrintWriterRunner", "writer", "Ljava/io/PrintWriter;", writer) + .await?; + jvm.put_field(&mut this, "PrintWriterRunner", "value", "I", value).await?; + jvm.put_field(&mut this, "PrintWriterRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "PrintWriterRunner", "done", "Z", false).await } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/PrintWriter;").await?; - let value: i32 = jvm.get_field(&this, "value", "I").await?; + jvm.put_field(&mut this, "PrintWriterRunner", "started", "Z", true).await?; + let writer: ClassInstanceRef = jvm.get_field(&this, "PrintWriterRunner", "writer", "Ljava/io/PrintWriter;").await?; + let value: i32 = jvm.get_field(&this, "PrintWriterRunner", "value", "I").await?; let _: () = jvm.invoke_virtual(&writer, "java/io/PrintWriter", "println", "(I)V", (value,)).await?; - jvm.put_field(&mut this, "done", "Z", true).await + jvm.put_field(&mut this, "PrintWriterRunner", "done", "Z", true).await } } @@ -255,16 +257,17 @@ impl PrintWriterCloseRunner { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, writer: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "writer", "Ljava/io/PrintWriter;", writer).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await + jvm.put_field(&mut this, "PrintWriterCloseRunner", "writer", "Ljava/io/PrintWriter;", writer) + .await?; + jvm.put_field(&mut this, "PrintWriterCloseRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "PrintWriterCloseRunner", "done", "Z", false).await } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let writer: ClassInstanceRef = jvm.get_field(&this, "writer", "Ljava/io/PrintWriter;").await?; + jvm.put_field(&mut this, "PrintWriterCloseRunner", "started", "Z", true).await?; + let writer: ClassInstanceRef = jvm.get_field(&this, "PrintWriterCloseRunner", "writer", "Ljava/io/PrintWriter;").await?; let _: () = jvm.invoke_virtual(&writer, "java/io/PrintWriter", "close", "()V", ()).await?; - jvm.put_field(&mut this, "done", "Z", true).await + jvm.put_field(&mut this, "PrintWriterCloseRunner", "done", "Z", true).await } } @@ -404,26 +407,31 @@ async fn pw_01_constructors_fields_descriptors_and_access_flags() -> Result<()> let jvm = probe_jvm().await?; let writer: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 0, 0)).await?.into(); let default_writer = jvm.new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (writer.clone(),)).await?; - assert!(!jvm.get_field::(&default_writer, "autoFlush", "Z").await?); - assert!(!jvm.get_field::(&default_writer, "trouble", "Z").await?); - let lock: ClassInstanceRef = jvm.get_field(&default_writer, "lock", "Ljava/lang/Object;").await?; + assert!(!jvm.get_field::(&default_writer, "java/io/PrintWriter", "autoFlush", "Z").await?); + assert!(!jvm.get_field::(&default_writer, "java/io/PrintWriter", "trouble", "Z").await?); + let lock: ClassInstanceRef = jvm + .get_field(&default_writer, "java/io/PrintWriter", "lock", "Ljava/lang/Object;") + .await?; assert_eq!(lock.identity(), writer.identity()); - let stored_out: ClassInstanceRef = jvm.get_field(&default_writer, "out", "Ljava/io/Writer;").await?; + let stored_out: ClassInstanceRef = jvm.get_field(&default_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; assert_eq!(stored_out.identity(), writer.identity()); let configured_writer = jvm .new_class("java/io/PrintWriter", "(Ljava/io/Writer;Z)V", (writer.clone(), true)) .await?; - assert!(jvm.get_field::(&configured_writer, "autoFlush", "Z").await?); + assert!(jvm.get_field::(&configured_writer, "java/io/PrintWriter", "autoFlush", "Z").await?); let output: ClassInstanceRef = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?.into(); let output_writer = jvm .new_class("java/io/PrintWriter", "(Ljava/io/OutputStream;Z)V", (output.clone(), true)) .await?; - assert!(jvm.get_field::(&output_writer, "autoFlush", "Z").await?); + assert!(jvm.get_field::(&output_writer, "java/io/PrintWriter", "autoFlush", "Z").await?); let default_output_writer = jvm .new_class("java/io/PrintWriter", "(Ljava/io/OutputStream;)V", (output.clone(),)) .await?; - assert!(!jvm.get_field::(&default_output_writer, "autoFlush", "Z").await?); + assert!( + !jvm.get_field::(&default_output_writer, "java/io/PrintWriter", "autoFlush", "Z") + .await? + ); let output_text = JavaLangString::from_rust_string(&jvm, "os").await?; let _: () = jvm .invoke_virtual( @@ -515,7 +523,7 @@ async fn pw_02_write_overloads_suppress_only_ioexception() -> Result<()> { panic!("invalid String range must throw IndexOutOfBoundsException"); }; assert!(jvm.is_instance(&*exception, "java/lang/IndexOutOfBoundsException")); - assert!(!jvm.get_field::(&writer, "trouble", "Z").await?); + assert!(!jvm.get_field::(&writer, "java/io/PrintWriter", "trouble", "Z").await?); let null_chars: ClassInstanceRef> = None.into(); let null_chars_result: Result<()> = jvm.invoke_virtual(&writer, "java/io/Writer", "write", "([C)V", (null_chars,)).await; @@ -539,7 +547,7 @@ async fn pw_02_write_overloads_suppress_only_ioexception() -> Result<()> { let _: () = jvm .invoke_virtual(&suppressing, &suppressing.class_definition().name(), "write", "(I)V", ('x' as i32,)) .await?; - assert!(jvm.get_field::(&suppressing, "trouble", "Z").await?); + assert!(jvm.get_field::(&suppressing, "java/io/PrintWriter", "trouble", "Z").await?); assert_monitor_released(&jvm, &failing_writer).await?; let runtime_writer: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (2, 0, 0)).await?.into(); @@ -553,7 +561,7 @@ async fn pw_02_write_overloads_suppress_only_ioexception() -> Result<()> { panic!("user RuntimeException must propagate"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert!(!jvm.get_field::(&propagating, "trouble", "Z").await?); + assert!(!jvm.get_field::(&propagating, "java/io/PrintWriter", "trouble", "Z").await?); assert_monitor_released(&jvm, &runtime_writer).await?; Ok(()) @@ -631,18 +639,18 @@ async fn pw_04_println_uses_line_separator_and_is_the_only_autoflush_path() -> R let _: () = jvm .invoke_virtual(&writer, "java/io/PrintWriter", "print", "(Ljava/lang/String;)V", (prefix,)) .await?; - assert_eq!(jvm.get_field::(&probe, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&probe, "ProbeWriter", "flushCount", "I").await?, 0); let newline = JavaLangString::from_rust_string(&jvm, "\n").await?; let _: () = jvm .invoke_virtual(&writer, "java/io/Writer", "write", "(Ljava/lang/String;)V", (newline,)) .await?; - assert_eq!(jvm.get_field::(&probe, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&probe, "ProbeWriter", "flushCount", "I").await?, 0); let _: () = jvm.invoke_virtual(&writer, "java/io/PrintWriter", "println", "(I)V", (7,)).await?; - assert_eq!(jvm.get_field::(&probe, "flushCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&probe, "ProbeWriter", "flushCount", "I").await?, 1); let _: () = jvm.invoke_virtual(&writer, "java/io/PrintWriter", "println", "()V", ()).await?; - assert_eq!(jvm.get_field::(&probe, "flushCount", "I").await?, 2); + assert_eq!(jvm.get_field::(&probe, "ProbeWriter", "flushCount", "I").await?, 2); - let content: ClassInstanceRef = jvm.get_field(&probe, "content", "Ljava/lang/StringBuffer;").await?; + let content: ClassInstanceRef = jvm.get_field(&probe, "ProbeWriter", "content", "Ljava/lang/StringBuffer;").await?; let content: ClassInstanceRef = jvm .invoke_virtual(&content, "java/lang/StringBuffer", "toString", "()Ljava/lang/String;", ()) .await?; @@ -655,7 +663,7 @@ async fn pw_04_println_uses_line_separator_and_is_the_only_autoflush_path() -> R let _: () = jvm .invoke_virtual(&no_flush_writer, &no_flush_writer.class_definition().name(), "println", "()V", ()) .await?; - assert_eq!(jvm.get_field::(&no_flush_probe, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&no_flush_probe, "ProbeWriter", "flushCount", "I").await?, 0); let newline_failure: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (1, 0, 0)).await?.into(); let newline_failure_writer = jvm @@ -670,9 +678,12 @@ async fn pw_04_println_uses_line_separator_and_is_the_only_autoflush_path() -> R (), ) .await?; - assert_eq!(jvm.get_field::(&newline_failure, "writeCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&newline_failure, "flushCount", "I").await?, 0); - assert!(jvm.get_field::(&newline_failure_writer, "trouble", "Z").await?); + assert_eq!(jvm.get_field::(&newline_failure, "ProbeWriter", "writeCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&newline_failure, "ProbeWriter", "flushCount", "I").await?, 0); + assert!( + jvm.get_field::(&newline_failure_writer, "java/io/PrintWriter", "trouble", "Z") + .await? + ); assert_monitor_released(&jvm, &newline_failure).await?; let fallback_jvm = test_jvm().await?; @@ -708,14 +719,16 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> let _: () = jvm .invoke_virtual(&overriding_writer, &overriding_writer.class_definition().name(), "println", "(I)V", (7,)) .await?; - let dispatch_content: ClassInstanceRef = jvm.get_field(&dispatch_probe, "content", "Ljava/lang/StringBuffer;").await?; + let dispatch_content: ClassInstanceRef = jvm + .get_field(&dispatch_probe, "ProbeWriter", "content", "Ljava/lang/StringBuffer;") + .await?; let dispatch_content: ClassInstanceRef = jvm .invoke_virtual(&dispatch_content, "java/lang/StringBuffer", "toString", "()Ljava/lang/String;", ()) .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &dispatch_content).await?, "<7>"); let mut blocking_probe: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 0, 0)).await?.into(); - jvm.put_field(&mut blocking_probe, "blockFirstWrite", "Z", true).await?; + jvm.put_field(&mut blocking_probe, "ProbeWriter", "blockFirstWrite", "Z", true).await?; let writer: ClassInstanceRef = jvm .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (blocking_probe.clone(),)) .await? @@ -736,7 +749,7 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> .await?; let mut first_write_entered = false; for _ in 0..100 { - first_write_entered = jvm.get_field::(&blocking_probe, "firstWriteEntered", "Z").await?; + first_write_entered = jvm.get_field::(&blocking_probe, "ProbeWriter", "firstWriteEntered", "Z").await?; if first_write_entered { break; } @@ -749,7 +762,7 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> .await?; let mut second_started = false; for _ in 0..100 { - second_started = jvm.get_field::(&second_runner, "started", "Z").await?; + second_started = jvm.get_field::(&second_runner, "PrintWriterRunner", "started", "Z").await?; if second_started { break; } @@ -758,30 +771,32 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> tokio::time::sleep(Duration::from_millis(10)).await; assert!(second_started, "second println worker did not start"); assert_eq!( - jvm.get_field::(&blocking_probe, "writeCount", "I").await?, + jvm.get_field::(&blocking_probe, "ProbeWriter", "writeCount", "I").await?, 1, "second println entered the backing writer before the first line completed" ); - assert!(!jvm.get_field::(&second_runner, "done", "Z").await?); + assert!(!jvm.get_field::(&second_runner, "PrintWriterRunner", "done", "Z").await?); - jvm.put_field(&mut blocking_probe, "releaseFirstWrite", "Z", true).await?; + jvm.put_field(&mut blocking_probe, "ProbeWriter", "releaseFirstWrite", "Z", true).await?; let _: () = jvm .invoke_virtual(&first_thread, &first_thread.class_definition().name(), "join", "()V", ()) .await?; let _: () = jvm .invoke_virtual(&second_thread, &second_thread.class_definition().name(), "join", "()V", ()) .await?; - assert!(jvm.get_field::(&first_runner, "done", "Z").await?); - assert!(jvm.get_field::(&second_runner, "done", "Z").await?); + assert!(jvm.get_field::(&first_runner, "PrintWriterRunner", "done", "Z").await?); + assert!(jvm.get_field::(&second_runner, "PrintWriterRunner", "done", "Z").await?); - let content: ClassInstanceRef = jvm.get_field(&blocking_probe, "content", "Ljava/lang/StringBuffer;").await?; + let content: ClassInstanceRef = jvm + .get_field(&blocking_probe, "ProbeWriter", "content", "Ljava/lang/StringBuffer;") + .await?; let content: ClassInstanceRef = jvm .invoke_virtual(&content, "java/lang/StringBuffer", "toString", "()Ljava/lang/String;", ()) .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &content).await?, "1\n2\n"); let mut close_probe: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 0, 0)).await?.into(); - jvm.put_field(&mut close_probe, "blockFirstClose", "Z", true).await?; + jvm.put_field(&mut close_probe, "ProbeWriter", "blockFirstClose", "Z", true).await?; let close_writer: ClassInstanceRef = jvm .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (close_probe.clone(),)) .await? @@ -804,7 +819,7 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> .await?; let mut first_close_entered = false; for _ in 0..100 { - first_close_entered = jvm.get_field::(&close_probe, "firstCloseEntered", "Z").await?; + first_close_entered = jvm.get_field::(&close_probe, "ProbeWriter", "firstCloseEntered", "Z").await?; if first_close_entered { break; } @@ -817,7 +832,9 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> .await?; let mut second_close_started = false; for _ in 0..100 { - second_close_started = jvm.get_field::(&second_close_runner, "started", "Z").await?; + second_close_started = jvm + .get_field::(&second_close_runner, "PrintWriterCloseRunner", "started", "Z") + .await?; if second_close_started { break; } @@ -825,20 +842,20 @@ async fn pw_04_println_is_atomic_and_uses_java_virtual_dispatch() -> Result<()> } tokio::time::sleep(Duration::from_millis(10)).await; assert!(second_close_started, "second close worker did not start"); - assert_eq!(jvm.get_field::(&close_probe, "closeCount", "I").await?, 1); - assert!(!jvm.get_field::(&second_close_runner, "done", "Z").await?); + assert_eq!(jvm.get_field::(&close_probe, "ProbeWriter", "closeCount", "I").await?, 1); + assert!(!jvm.get_field::(&second_close_runner, "PrintWriterCloseRunner", "done", "Z").await?); - jvm.put_field(&mut close_probe, "releaseFirstClose", "Z", true).await?; + jvm.put_field(&mut close_probe, "ProbeWriter", "releaseFirstClose", "Z", true).await?; let _: () = jvm .invoke_virtual(&first_close_thread, &first_close_thread.class_definition().name(), "join", "()V", ()) .await?; let _: () = jvm .invoke_virtual(&second_close_thread, &second_close_thread.class_definition().name(), "join", "()V", ()) .await?; - assert!(jvm.get_field::(&first_close_runner, "done", "Z").await?); - assert!(jvm.get_field::(&second_close_runner, "done", "Z").await?); - assert_eq!(jvm.get_field::(&close_probe, "closeCount", "I").await?, 1); - let closed_out: ClassInstanceRef = jvm.get_field(&close_writer, "out", "Ljava/io/Writer;").await?; + assert!(jvm.get_field::(&first_close_runner, "PrintWriterCloseRunner", "done", "Z").await?); + assert!(jvm.get_field::(&second_close_runner, "PrintWriterCloseRunner", "done", "Z").await?); + assert_eq!(jvm.get_field::(&close_probe, "ProbeWriter", "closeCount", "I").await?, 1); + let closed_out: ClassInstanceRef = jvm.get_field(&close_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; assert!(closed_out.is_null()); Ok(()) @@ -856,13 +873,13 @@ async fn pw_05_flush_close_and_check_error_preserve_trouble_state() -> Result<() jvm.invoke_virtual::<_, bool>(&flush_writer, &flush_writer.class_definition().name(), "checkError", "()Z", ()) .await? ); - assert_eq!(jvm.get_field::(&flush_failure, "flushCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&flush_failure, "ProbeWriter", "flushCount", "I").await?, 1); assert_monitor_released(&jvm, &flush_failure).await?; - jvm.put_field(&mut flush_failure, "flushMode", "I", 0).await?; + jvm.put_field(&mut flush_failure, "ProbeWriter", "flushMode", "I", 0).await?; let _: () = jvm .invoke_virtual(&flush_writer, &flush_writer.class_definition().name(), "flush", "()V", ()) .await?; - assert!(jvm.get_field::(&flush_writer, "trouble", "Z").await?); + assert!(jvm.get_field::(&flush_writer, "java/io/PrintWriter", "trouble", "Z").await?); let nested_failure: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 1, 0)).await?.into(); let inner_writer: ClassInstanceRef = jvm @@ -880,18 +897,18 @@ async fn pw_05_flush_close_and_check_error_preserve_trouble_state() -> Result<() .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (close_failure.clone(),)) .await?; let _: () = jvm.invoke_virtual(&close_writer, "java/io/PrintWriter", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&close_failure, "closeCount", "I").await?, 1); - let open_after_failure: ClassInstanceRef = jvm.get_field(&close_writer, "out", "Ljava/io/Writer;").await?; + assert_eq!(jvm.get_field::(&close_failure, "ProbeWriter", "closeCount", "I").await?, 1); + let open_after_failure: ClassInstanceRef = jvm.get_field(&close_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; assert!(!open_after_failure.is_null()); - assert!(jvm.get_field::(&close_writer, "trouble", "Z").await?); + assert!(jvm.get_field::(&close_writer, "java/io/PrintWriter", "trouble", "Z").await?); assert_monitor_released(&jvm, &close_failure).await?; - jvm.put_field(&mut close_failure, "closeMode", "I", 0).await?; + jvm.put_field(&mut close_failure, "ProbeWriter", "closeMode", "I", 0).await?; let _: () = jvm.invoke_virtual(&close_writer, "java/io/PrintWriter", "close", "()V", ()).await?; let _: () = jvm.invoke_virtual(&close_writer, "java/io/PrintWriter", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&close_failure, "closeCount", "I").await?, 2); - assert!(jvm.get_field::(&close_writer, "trouble", "Z").await?); - let closed_out: ClassInstanceRef = jvm.get_field(&close_writer, "out", "Ljava/io/Writer;").await?; + assert_eq!(jvm.get_field::(&close_failure, "ProbeWriter", "closeCount", "I").await?, 2); + assert!(jvm.get_field::(&close_writer, "java/io/PrintWriter", "trouble", "Z").await?); + let closed_out: ClassInstanceRef = jvm.get_field(&close_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;").await?; assert!(closed_out.is_null()); let closed_probe: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 0, 0)).await?.into(); @@ -911,8 +928,8 @@ async fn pw_05_flush_close_and_check_error_preserve_trouble_state() -> Result<() jvm.invoke_virtual::<_, bool>(&closed_writer, &closed_writer.class_definition().name(), "checkError", "()Z", ()) .await? ); - assert_eq!(jvm.get_field::(&closed_probe, "writeCount", "I").await?, 0); - assert_eq!(jvm.get_field::(&closed_probe, "flushCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&closed_probe, "ProbeWriter", "writeCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&closed_probe, "ProbeWriter", "flushCount", "I").await?, 0); let runtime_flush: ClassInstanceRef = jvm.new_class("ProbeWriter", "(III)V", (0, 2, 0)).await?.into(); let runtime_flush_writer = jvm @@ -938,14 +955,18 @@ async fn pw_05_flush_close_and_check_error_preserve_trouble_state() -> Result<() panic!("close RuntimeException must propagate"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - let open_after_runtime: ClassInstanceRef = jvm.get_field(&runtime_close_writer, "out", "Ljava/io/Writer;").await?; + let open_after_runtime: ClassInstanceRef = jvm + .get_field(&runtime_close_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;") + .await?; assert!(!open_after_runtime.is_null()); assert_monitor_released(&jvm, &runtime_close).await?; - jvm.put_field(&mut runtime_close, "closeMode", "I", 0).await?; + jvm.put_field(&mut runtime_close, "ProbeWriter", "closeMode", "I", 0).await?; let _: () = jvm .invoke_virtual(&runtime_close_writer, &runtime_close_writer.class_definition().name(), "close", "()V", ()) .await?; - let closed_after_retry: ClassInstanceRef = jvm.get_field(&runtime_close_writer, "out", "Ljava/io/Writer;").await?; + let closed_after_retry: ClassInstanceRef = jvm + .get_field(&runtime_close_writer, "java/io/PrintWriter", "out", "Ljava/io/Writer;") + .await?; assert!(closed_after_retry.is_null()); Ok(()) diff --git a/rustjava-runtime/tests/classes/java/io/test_stream_locking.rs b/rustjava-runtime/tests/classes/java/io/test_stream_locking.rs index 4bd93eb8..d778f3c1 100644 --- a/rustjava-runtime/tests/classes/java/io/test_stream_locking.rs +++ b/rustjava-runtime/tests/classes/java/io/test_stream_locking.rs @@ -42,12 +42,12 @@ impl LockCheckingWriter { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, fail_writes: i32, fail_close: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/Writer", "", "()V", ()).await?; - jvm.put_field(&mut this, "failWrites", "I", fail_writes).await?; - jvm.put_field(&mut this, "failClose", "Z", fail_close).await?; - jvm.put_field(&mut this, "writeCalls", "I", 0).await?; - jvm.put_field(&mut this, "flushCalls", "I", 0).await?; - jvm.put_field(&mut this, "closeCalls", "I", 0).await?; - jvm.put_field(&mut this, "written", "I", 0).await + jvm.put_field(&mut this, "LockCheckingWriter", "failWrites", "I", fail_writes).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "failClose", "Z", fail_close).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "writeCalls", "I", 0).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "flushCalls", "I", 0).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "closeCalls", "I", 0).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "written", "I", 0).await } async fn write( @@ -59,28 +59,28 @@ impl LockCheckingWriter { length: i32, ) -> Result<()> { jvm.object_notify(&this, 1).await?; - let calls: i32 = jvm.get_field(&this, "writeCalls", "I").await?; - jvm.put_field(&mut this, "writeCalls", "I", calls + 1).await?; - let failures: i32 = jvm.get_field(&this, "failWrites", "I").await?; + let calls: i32 = jvm.get_field(&this, "LockCheckingWriter", "writeCalls", "I").await?; + jvm.put_field(&mut this, "LockCheckingWriter", "writeCalls", "I", calls + 1).await?; + let failures: i32 = jvm.get_field(&this, "LockCheckingWriter", "failWrites", "I").await?; if failures > 0 { - jvm.put_field(&mut this, "failWrites", "I", failures - 1).await?; + jvm.put_field(&mut this, "LockCheckingWriter", "failWrites", "I", failures - 1).await?; return Err(jvm.exception("java/io/IOException", "write failed").await); } - let written: i32 = jvm.get_field(&this, "written", "I").await?; - jvm.put_field(&mut this, "written", "I", written + length).await + let written: i32 = jvm.get_field(&this, "LockCheckingWriter", "written", "I").await?; + jvm.put_field(&mut this, "LockCheckingWriter", "written", "I", written + length).await } async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { jvm.object_notify(&this, 1).await?; - let calls: i32 = jvm.get_field(&this, "flushCalls", "I").await?; - jvm.put_field(&mut this, "flushCalls", "I", calls + 1).await + let calls: i32 = jvm.get_field(&this, "LockCheckingWriter", "flushCalls", "I").await?; + jvm.put_field(&mut this, "LockCheckingWriter", "flushCalls", "I", calls + 1).await } async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { jvm.object_notify(&this, 1).await?; - let calls: i32 = jvm.get_field(&this, "closeCalls", "I").await?; - jvm.put_field(&mut this, "closeCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "failClose", "Z").await? { + let calls: i32 = jvm.get_field(&this, "LockCheckingWriter", "closeCalls", "I").await?; + jvm.put_field(&mut this, "LockCheckingWriter", "closeCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "LockCheckingWriter", "failClose", "Z").await? { return Err(jvm.exception("java/io/IOException", "close failed").await); } Ok(()) @@ -117,16 +117,17 @@ impl StreamOperationRunner { operation: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "target", "Ljava/lang/Object;", target).await?; - jvm.put_field(&mut this, "operation", "I", operation).await?; - jvm.put_field(&mut this, "started", "Z", false).await?; - jvm.put_field(&mut this, "done", "Z", false).await + jvm.put_field(&mut this, "StreamOperationRunner", "target", "Ljava/lang/Object;", target) + .await?; + jvm.put_field(&mut this, "StreamOperationRunner", "operation", "I", operation).await?; + jvm.put_field(&mut this, "StreamOperationRunner", "started", "Z", false).await?; + jvm.put_field(&mut this, "StreamOperationRunner", "done", "Z", false).await } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "started", "Z", true).await?; - let target: ClassInstanceRef = jvm.get_field(&this, "target", "Ljava/lang/Object;").await?; - match jvm.get_field::(&this, "operation", "I").await? { + jvm.put_field(&mut this, "StreamOperationRunner", "started", "Z", true).await?; + let target: ClassInstanceRef = jvm.get_field(&this, "StreamOperationRunner", "target", "Ljava/lang/Object;").await?; + match jvm.get_field::(&this, "StreamOperationRunner", "operation", "I").await? { 0 => { let _: i32 = jvm.invoke_virtual(&target, &target.class_definition().name(), "read", "()I", ()).await?; } @@ -144,7 +145,7 @@ impl StreamOperationRunner { .await?; } } - jvm.put_field(&mut this, "done", "Z", true).await + jvm.put_field(&mut this, "StreamOperationRunner", "done", "Z", true).await } } @@ -191,20 +192,20 @@ async fn assert_worker_waits_for_lock(jvm: &Jvm, target: ClassInstanceRef(&runner, "started", "Z").await?; + started = jvm.get_field::(&runner, "StreamOperationRunner", "started", "Z").await?; if started { break; } tokio::time::sleep(Duration::from_millis(1)).await; } tokio::time::sleep(Duration::from_millis(10)).await; - let completed_while_locked = jvm.get_field::(&runner, "done", "Z").await?; + let completed_while_locked = jvm.get_field::(&runner, "StreamOperationRunner", "done", "Z").await?; jvm.monitor_exit(&lock).await?; let _: () = jvm.invoke_virtual(&thread, &thread.class_definition().name(), "join", "()V", ()).await?; assert!(started, "worker thread did not start"); assert!(!completed_while_locked, "state operation did not synchronize on inherited lock"); - assert!(jvm.get_field::(&runner, "done", "Z").await?); + assert!(jvm.get_field::(&runner, "StreamOperationRunner", "done", "Z").await?); Ok(()) } @@ -217,7 +218,7 @@ async fn buffered_writer_preserves_state_and_closes_after_backing_failures() -> .new_class("java/io/BufferedWriter", "(Ljava/io/Writer;I)V", (backing_writer, 4)) .await? .into(); - let lock: ClassInstanceRef = jvm.get_field(&writer, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&writer, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; assert_eq!(lock.identity(), backing.identity()); let _: () = jvm @@ -231,23 +232,23 @@ async fn buffered_writer_preserves_state_and_closes_after_backing_failures() -> panic!("backing write failure must escape BufferedWriter.flush"); }; assert!(jvm.is_instance(&*exception, "java/io/IOException")); - assert_eq!(jvm.get_field::(&writer, "nextChar", "I").await?, 2); - assert_eq!(jvm.get_field::(&backing, "written", "I").await?, 0); + assert_eq!(jvm.get_field::(&writer, "java/io/BufferedWriter", "nextChar", "I").await?, 2); + assert_eq!(jvm.get_field::(&backing, "LockCheckingWriter", "written", "I").await?, 0); assert_monitor_released(&jvm, &lock).await?; let _: () = jvm.invoke_virtual(&writer, "java/io/BufferedWriter", "flush", "()V", ()).await?; - assert_eq!(jvm.get_field::(&writer, "nextChar", "I").await?, 0); - assert_eq!(jvm.get_field::(&backing, "written", "I").await?, 2); + assert_eq!(jvm.get_field::(&writer, "java/io/BufferedWriter", "nextChar", "I").await?, 0); + assert_eq!(jvm.get_field::(&backing, "LockCheckingWriter", "written", "I").await?, 2); - jvm.put_field(&mut backing, "failClose", "Z", true).await?; + jvm.put_field(&mut backing, "LockCheckingWriter", "failClose", "Z", true).await?; let failed_close: Result<()> = jvm.invoke_virtual(&writer, "java/io/BufferedWriter", "close", "()V", ()).await; let Err(JavaError::JavaException(exception)) = failed_close else { panic!("backing close failure must escape BufferedWriter.close"); }; assert!(jvm.is_instance(&*exception, "java/io/IOException")); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "LockCheckingWriter", "closeCalls", "I").await?, 1); let _: () = jvm.invoke_virtual(&writer, "java/io/BufferedWriter", "close", "()V", ()).await?; - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "LockCheckingWriter", "closeCalls", "I").await?, 1); let closed: Result<()> = jvm .invoke_virtual(&writer, "java/io/BufferedWriter", "write", "(I)V", ('C' as i32,)) .await; @@ -271,8 +272,8 @@ async fn buffered_writer_preserves_state_and_closes_after_backing_failures() -> panic!("close must report a buffered backing write failure"); }; assert!(jvm.is_instance(&*exception, "java/io/IOException")); - assert_eq!(jvm.get_field::(&writer, "nextChar", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing, "closeCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&writer, "java/io/BufferedWriter", "nextChar", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing, "LockCheckingWriter", "closeCalls", "I").await?, 1); let closed: Result<()> = jvm .invoke_virtual(&writer, "java/io/BufferedWriter", "write", "(I)V", ('Y' as i32,)) .await; @@ -298,7 +299,9 @@ async fn character_streams_release_inherited_locks_after_errors() -> Result<()> ) .await; assert!(invalid.is_err()); - let lock: ClassInstanceRef = jvm.get_field(&string_reader, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&string_reader, "java/io/StringReader", "lock", "Ljava/lang/Object;") + .await?; assert_eq!(lock.identity(), string_reader.identity()); assert_monitor_released(&jvm, &lock).await?; @@ -309,7 +312,9 @@ async fn character_streams_release_inherited_locks_after_errors() -> Result<()> .invoke_virtual(&char_reader, &char_reader.class_definition().name(), "read", "([CII)I", (target, 2, 1)) .await; assert!(invalid.is_err()); - let lock: ClassInstanceRef = jvm.get_field(&char_reader, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&char_reader, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;") + .await?; assert_eq!(lock.identity(), char_reader.identity()); assert_monitor_released(&jvm, &lock).await?; @@ -325,7 +330,9 @@ async fn character_streams_release_inherited_locks_after_errors() -> Result<()> ) .await; assert!(invalid.is_err()); - let lock: ClassInstanceRef = jvm.get_field(&char_writer, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&char_writer, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;") + .await?; assert_eq!(lock.identity(), char_writer.identity()); assert_monitor_released(&jvm, &lock).await?; @@ -345,13 +352,15 @@ async fn character_stream_operations_and_close_wait_for_inherited_locks() -> Res ) .await? .into(); - let lock: ClassInstanceRef = jvm.get_field(&writer, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm.get_field(&writer, "java/io/BufferedWriter", "lock", "Ljava/lang/Object;").await?; assert_worker_waits_for_lock(&jvm, writer.instance.clone().into(), lock.clone(), 3).await?; assert_worker_waits_for_lock(&jvm, writer.instance.into(), lock, 2).await?; let value = JavaLangString::from_rust_string(&jvm, "abc").await?; let string_reader: ClassInstanceRef = jvm.new_class("java/io/StringReader", "(Ljava/lang/String;)V", (value,)).await?.into(); - let lock: ClassInstanceRef = jvm.get_field(&string_reader, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&string_reader, "java/io/StringReader", "lock", "Ljava/lang/Object;") + .await?; assert_worker_waits_for_lock(&jvm, string_reader.instance.clone().into(), lock.clone(), 0).await?; assert_worker_waits_for_lock(&jvm, string_reader.instance.clone().into(), lock, 2).await?; let closed: Result = jvm @@ -361,7 +370,9 @@ async fn character_stream_operations_and_close_wait_for_inherited_locks() -> Res let chars = jvm.instantiate_array("C", 1).await?; let char_reader: ClassInstanceRef = jvm.new_class("java/io/CharArrayReader", "([C)V", (chars,)).await?.into(); - let lock: ClassInstanceRef = jvm.get_field(&char_reader, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&char_reader, "java/io/CharArrayReader", "lock", "Ljava/lang/Object;") + .await?; assert_worker_waits_for_lock(&jvm, char_reader.instance.clone().into(), lock, 2).await?; let closed: Result = jvm .invoke_virtual(&char_reader, &char_reader.class_definition().name(), "read", "()I", ()) @@ -369,7 +380,9 @@ async fn character_stream_operations_and_close_wait_for_inherited_locks() -> Res assert!(closed.is_err()); let char_writer: ClassInstanceRef = jvm.new_class("java/io/CharArrayWriter", "()V", ()).await?.into(); - let lock: ClassInstanceRef = jvm.get_field(&char_writer, "lock", "Ljava/lang/Object;").await?; + let lock: ClassInstanceRef = jvm + .get_field(&char_writer, "java/io/CharArrayWriter", "lock", "Ljava/lang/Object;") + .await?; assert_worker_waits_for_lock(&jvm, char_writer.instance.clone().into(), lock, 1).await?; assert_eq!( jvm.invoke_virtual::<_, i32>(&char_writer, &char_writer.class_definition().name(), "size", "()I", ()) diff --git a/rustjava-runtime/tests/classes/java/lang/test_class.rs b/rustjava-runtime/tests/classes/java/lang/test_class.rs index e1f21144..bdaedced 100644 --- a/rustjava-runtime/tests/classes/java/lang/test_class.rs +++ b/rustjava-runtime/tests/classes/java/lang/test_class.rs @@ -548,17 +548,28 @@ async fn test_system_class_loader_uses_rustjar_parent() -> Result<()> { let system_class_loader: ClassInstanceRef = jvm .invoke_static("java/lang/ClassLoader", "getSystemClassLoader", "()Ljava/lang/ClassLoader;", ()) .await?; - let rustjar_class_loader: ClassInstanceRef = jvm.get_field(&system_class_loader, "parent", "Ljava/lang/ClassLoader;").await?; + let rustjar_class_loader: ClassInstanceRef = jvm + .get_field(&system_class_loader, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;") + .await?; assert!(jvm.is_instance(&**rustjar_class_loader, "org/rustjava/lang/RustJarClassLoader")); - let class_paths: ClassInstanceRef> = jvm.get_field(&rustjar_class_loader, "classPaths", "[Ljava/lang/String;").await?; + let class_paths: ClassInstanceRef> = jvm + .get_field( + &rustjar_class_loader, + "org/rustjava/lang/RustJarClassLoader", + "classPaths", + "[Ljava/lang/String;", + ) + .await?; assert_eq!(jvm.array_length(&class_paths).await?, 2); let class_paths: Vec> = jvm.load_array(&class_paths, 0, 2).await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &class_paths[0]).await?, "external.rustjar"); assert_eq!(JavaLangString::to_rust_string(&jvm, &class_paths[1]).await?, "classes"); - let urls: ClassInstanceRef> = jvm.get_field(&system_class_loader, "urls", "[Ljava/net/URL;").await?; + let urls: ClassInstanceRef> = jvm + .get_field(&system_class_loader, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;") + .await?; assert_eq!(jvm.array_length(&urls).await?, 2); let urls: Vec> = jvm.load_array(&urls, 0, 2).await?; let rustjar_file: ClassInstanceRef = jvm diff --git a/rustjava-runtime/tests/classes/java/lang/test_object.rs b/rustjava-runtime/tests/classes/java/lang/test_object.rs index ce8c2b2f..e9f274f0 100644 --- a/rustjava-runtime/tests/classes/java/lang/test_object.rs +++ b/rustjava-runtime/tests/classes/java/lang/test_object.rs @@ -156,21 +156,22 @@ async fn test_clone_creates_shallow_object_and_array_copies() -> Result<()> { let mut original = jvm.instantiate_class("CloneableObject").await?; let reference = jvm.new_class("java/lang/Object", "()V", ()).await?; - jvm.put_field(&mut original, "value", "I", 7i32).await?; - jvm.put_field(&mut original, "reference", "Ljava/lang/Object;", reference.clone()).await?; + jvm.put_field(&mut original, "CloneableObject", "value", "I", 7i32).await?; + jvm.put_field(&mut original, "CloneableObject", "reference", "Ljava/lang/Object;", reference.clone()) + .await?; let mut cloned: ClassInstanceRef = jvm .invoke_virtual(&original, &original.class_definition().name(), "clone", "()Ljava/lang/Object;", ()) .await?; assert_ne!(original.identity(), cloned.identity()); - assert_eq!(jvm.get_field::(&cloned, "value", "I").await?, 7); + assert_eq!(jvm.get_field::(&cloned, "CloneableObject", "value", "I").await?, 7); let cloned_reference = jvm - .get_field::>(&cloned, "reference", "Ljava/lang/Object;") + .get_field::>(&cloned, "CloneableObject", "reference", "Ljava/lang/Object;") .await?; assert_eq!(reference.identity(), cloned_reference.identity()); - jvm.put_field(&mut cloned, "value", "I", 9i32).await?; - assert_eq!(jvm.get_field::(&original, "value", "I").await?, 7); + jvm.put_field(&mut cloned, "CloneableObject", "value", "I", 9i32).await?; + assert_eq!(jvm.get_field::(&original, "CloneableObject", "value", "I").await?, 7); let mut array = jvm.instantiate_array("I", 2).await?; jvm.store_array(&mut array, 0, [1i32, 2i32]).await?; diff --git a/rustjava-runtime/tests/classes/java/lang/test_string.rs b/rustjava-runtime/tests/classes/java/lang/test_string.rs index 8e583b06..153e207f 100644 --- a/rustjava-runtime/tests/classes/java/lang/test_string.rs +++ b/rustjava-runtime/tests/classes/java/lang/test_string.rs @@ -1138,20 +1138,20 @@ async fn test_substring_shares_parent_value() -> Result<()> { .invoke_virtual(&parent, &parent.class_definition().name(), "substring", "(II)Ljava/lang/String;", (2, 5)) .await?; - let parent_value: ClassInstanceRef> = jvm.get_field(&parent, "value", "[C").await?; - let child_value: ClassInstanceRef> = jvm.get_field(&child, "value", "[C").await?; + let parent_value: ClassInstanceRef> = jvm.get_field(&parent, "java/lang/String", "value", "[C").await?; + let child_value: ClassInstanceRef> = jvm.get_field(&child, "java/lang/String", "value", "[C").await?; assert_eq!(parent_value.identity(), child_value.identity()); - assert_eq!(jvm.get_field::(&child, "offset", "I").await?, 2); - assert_eq!(jvm.get_field::(&child, "count", "I").await?, 3); + assert_eq!(jvm.get_field::(&child, "java/lang/String", "offset", "I").await?, 2); + assert_eq!(jvm.get_field::(&child, "java/lang/String", "count", "I").await?, 3); assert_eq!(JavaLangString::to_rust_string(&jvm, &child).await?, "llo"); let tail: ClassInstanceRef = jvm .invoke_virtual(&parent, &parent.class_definition().name(), "substring", "(I)Ljava/lang/String;", (5,)) .await?; - let tail_value: ClassInstanceRef> = jvm.get_field(&tail, "value", "[C").await?; + let tail_value: ClassInstanceRef> = jvm.get_field(&tail, "java/lang/String", "value", "[C").await?; assert_eq!(parent_value.identity(), tail_value.identity()); - assert_eq!(jvm.get_field::(&tail, "offset", "I").await?, 5); - assert_eq!(jvm.get_field::(&tail, "count", "I").await?, 5); + assert_eq!(jvm.get_field::(&tail, "java/lang/String", "offset", "I").await?, 5); + assert_eq!(jvm.get_field::(&tail, "java/lang/String", "count", "I").await?, 5); assert_eq!(JavaLangString::to_rust_string(&jvm, &tail).await?, "World"); Ok(()) @@ -1188,11 +1188,11 @@ async fn test_nested_substring_shares_root_value() -> Result<()> { .invoke_virtual(&outer, "java/lang/String", "substring", "(II)Ljava/lang/String;", (1, 3)) .await?; - let root_value: ClassInstanceRef> = jvm.get_field(&root, "value", "[C").await?; - let inner_value: ClassInstanceRef> = jvm.get_field(&inner, "value", "[C").await?; + let root_value: ClassInstanceRef> = jvm.get_field(&root, "java/lang/String", "value", "[C").await?; + let inner_value: ClassInstanceRef> = jvm.get_field(&inner, "java/lang/String", "value", "[C").await?; assert_eq!(root_value.identity(), inner_value.identity()); - assert_eq!(jvm.get_field::(&inner, "offset", "I").await?, 3); - assert_eq!(jvm.get_field::(&inner, "count", "I").await?, 2); + assert_eq!(jvm.get_field::(&inner, "java/lang/String", "offset", "I").await?, 3); + assert_eq!(jvm.get_field::(&inner, "java/lang/String", "count", "I").await?, 2); assert_eq!( jvm.invoke_virtual::<_, JavaChar>(&inner, "java/lang/String", "charAt", "(I)C", (0,)) .await?, @@ -1217,7 +1217,7 @@ async fn test_init_partial_char_array_is_defensive_copy() -> Result<()> { let string = jvm.new_class("java/lang/String", "([CII)V", (chars.clone(), 1, 3)).await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &string).await?, "ell"); - let value: ClassInstanceRef> = jvm.get_field(&string, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&string, "java/lang/String", "value", "[C").await?; assert_ne!(value.identity(), chars.identity()); jvm.store_array(&mut chars, 0, "zzzzz".encode_utf16().collect::>()).await?; @@ -1235,7 +1235,7 @@ async fn test_to_char_array_returns_copy() -> Result<()> { .invoke_virtual(&string, &string.class_definition().name(), "toCharArray", "()[C", ()) .await?; - let value: ClassInstanceRef> = jvm.get_field(&string, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&string, "java/lang/String", "value", "[C").await?; assert_ne!(chars.identity(), value.identity()); assert_eq!(jvm.array_length(&chars).await?, 3); @@ -1475,11 +1475,11 @@ async fn test_trim_on_substring_shares_buffer() -> Result<()> { let trimmed: ClassInstanceRef = jvm.invoke_virtual(&sub, "java/lang/String", "trim", "()Ljava/lang/String;", ()).await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &trimmed).await?, "hi"); - let parent_value: ClassInstanceRef> = jvm.get_field(&parent, "value", "[C").await?; - let trimmed_value: ClassInstanceRef> = jvm.get_field(&trimmed, "value", "[C").await?; + let parent_value: ClassInstanceRef> = jvm.get_field(&parent, "java/lang/String", "value", "[C").await?; + let trimmed_value: ClassInstanceRef> = jvm.get_field(&trimmed, "java/lang/String", "value", "[C").await?; assert_eq!(parent_value.identity(), trimmed_value.identity()); - assert_eq!(jvm.get_field::(&trimmed, "offset", "I").await?, 4); - assert_eq!(jvm.get_field::(&trimmed, "count", "I").await?, 2); + assert_eq!(jvm.get_field::(&trimmed, "java/lang/String", "offset", "I").await?, 4); + assert_eq!(jvm.get_field::(&trimmed, "java/lang/String", "count", "I").await?, 2); let no_trim: ClassInstanceRef = jvm .invoke_virtual(&parent, &parent.class_definition().name(), "substring", "(II)Ljava/lang/String;", (4, 6)) @@ -1594,10 +1594,10 @@ async fn test_from_rust_string_representation() -> Result<()> { let string = JavaLangString::from_rust_string(&jvm, "test").await?; - let value: ClassInstanceRef> = jvm.get_field(&string, "value", "[C").await?; + let value: ClassInstanceRef> = jvm.get_field(&string, "java/lang/String", "value", "[C").await?; assert_eq!(jvm.array_length(&value).await?, 4); - assert_eq!(jvm.get_field::(&string, "offset", "I").await?, 0); - assert_eq!(jvm.get_field::(&string, "count", "I").await?, 4); + assert_eq!(jvm.get_field::(&string, "java/lang/String", "offset", "I").await?, 0); + assert_eq!(jvm.get_field::(&string, "java/lang/String", "count", "I").await?, 4); assert_eq!(JavaLangString::to_rust_string(&jvm, &string).await?, "test"); Ok(()) @@ -1610,11 +1610,11 @@ async fn test_init_with_string_shares_full_range_value() -> Result<()> { let original = JavaLangString::from_rust_string(&jvm, "Hello").await?; let copy = jvm.new_class("java/lang/String", "(Ljava/lang/String;)V", (original.clone(),)).await?; - let original_value: ClassInstanceRef> = jvm.get_field(&original, "value", "[C").await?; - let copy_value: ClassInstanceRef> = jvm.get_field(©, "value", "[C").await?; + let original_value: ClassInstanceRef> = jvm.get_field(&original, "java/lang/String", "value", "[C").await?; + let copy_value: ClassInstanceRef> = jvm.get_field(©, "java/lang/String", "value", "[C").await?; assert_eq!(original_value.identity(), copy_value.identity()); - assert_eq!(jvm.get_field::(©, "offset", "I").await?, 0); - assert_eq!(jvm.get_field::(©, "count", "I").await?, 5); + assert_eq!(jvm.get_field::(©, "java/lang/String", "offset", "I").await?, 0); + assert_eq!(jvm.get_field::(©, "java/lang/String", "count", "I").await?, 5); assert!( jvm.invoke_virtual::<_, bool>(©, ©.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (original,)) .await? @@ -1633,12 +1633,12 @@ async fn test_init_with_string_detaches_substring_with_exact_size_copy() -> Resu .await?; let detached = jvm.new_class("java/lang/String", "(Ljava/lang/String;)V", (sub.clone(),)).await?; - let sub_value: ClassInstanceRef> = jvm.get_field(&sub, "value", "[C").await?; - let detached_value: ClassInstanceRef> = jvm.get_field(&detached, "value", "[C").await?; + let sub_value: ClassInstanceRef> = jvm.get_field(&sub, "java/lang/String", "value", "[C").await?; + let detached_value: ClassInstanceRef> = jvm.get_field(&detached, "java/lang/String", "value", "[C").await?; assert_ne!(sub_value.identity(), detached_value.identity()); assert_eq!(jvm.array_length(&detached_value).await?, 3); - assert_eq!(jvm.get_field::(&detached, "offset", "I").await?, 0); - assert_eq!(jvm.get_field::(&detached, "count", "I").await?, 3); + assert_eq!(jvm.get_field::(&detached, "java/lang/String", "offset", "I").await?, 0); + assert_eq!(jvm.get_field::(&detached, "java/lang/String", "count", "I").await?, 3); assert!( jvm.invoke_virtual::<_, bool>(&detached, &detached.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (sub,)) .await? @@ -2405,7 +2405,7 @@ async fn test_corrupted_length_fields_raise_java_exceptions() -> Result<()> { for field in ["offset", "count"] { let mut string = JavaLangString::from_rust_string(&jvm, "Hello").await?; - jvm.put_field(&mut string, field, "I", -1i32).await?; + jvm.put_field(&mut string, "java/lang/String", field, "I", -1i32).await?; let result: Result = jvm .invoke_virtual(&string, &string.class_definition().name(), "hashCode", "()I", ()) @@ -2425,7 +2425,7 @@ async fn test_corrupted_length_fields_raise_java_exceptions() -> Result<()> { } let mut string = JavaLangString::from_rust_string(&jvm, "Hello").await?; - jvm.put_field(&mut string, "count", "I", i32::MAX).await?; + jvm.put_field(&mut string, "java/lang/String", "count", "I", i32::MAX).await?; let result: Result = jvm .invoke_virtual(&string, &string.class_definition().name(), "hashCode", "()I", ()) .await; diff --git a/rustjava-runtime/tests/classes/java/lang/test_string_buffer.rs b/rustjava-runtime/tests/classes/java/lang/test_string_buffer.rs index 3fb6c4a4..1114cf82 100644 --- a/rustjava-runtime/tests/classes/java/lang/test_string_buffer.rs +++ b/rustjava-runtime/tests/classes/java/lang/test_string_buffer.rs @@ -1040,12 +1040,12 @@ async fn test_sb_12_to_string_snapshot_is_exact_size_and_immutable() -> Result<( .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &string).await?, "Hello"); - let buffer_value: ClassInstanceRef> = jvm.get_field(&buffer, "value", "[C").await?; - let string_value: ClassInstanceRef> = jvm.get_field(&string, "value", "[C").await?; + let buffer_value: ClassInstanceRef> = jvm.get_field(&buffer, "java/lang/StringBuffer", "value", "[C").await?; + let string_value: ClassInstanceRef> = jvm.get_field(&string, "java/lang/String", "value", "[C").await?; assert_ne!(buffer_value.identity(), string_value.identity()); assert_eq!(jvm.array_length(&string_value).await?, 5); - assert_eq!(jvm.get_field::(&string, "offset", "I").await?, 0); - assert_eq!(jvm.get_field::(&string, "count", "I").await?, 5); + assert_eq!(jvm.get_field::(&string, "java/lang/String", "offset", "I").await?, 0); + assert_eq!(jvm.get_field::(&string, "java/lang/String", "count", "I").await?, 5); let world = JavaLangString::from_rust_string(&jvm, "World").await?; let _: ClassInstanceRef = jvm diff --git a/rustjava-runtime/tests/classes/java/lang/test_thread.rs b/rustjava-runtime/tests/classes/java/lang/test_thread.rs index 5b70b84d..c11dbf89 100644 --- a/rustjava-runtime/tests/classes/java/lang/test_thread.rs +++ b/rustjava-runtime/tests/classes/java/lang/test_thread.rs @@ -25,13 +25,13 @@ impl TestClass { } async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "ran", "Z", false).await?; + jvm.put_field(&mut this, "TestClass", "ran", "Z", false).await?; Ok(()) } async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { - jvm.put_field(&mut this, "ran", "Z", true).await?; + jvm.put_field(&mut this, "TestClass", "ran", "Z", true).await?; Ok(()) } @@ -57,7 +57,7 @@ async fn test_thread() -> Result<()> { let _: () = jvm.invoke_virtual(&thread, &thread.class_definition().name(), "join", "()V", []).await?; - let ran: bool = jvm.get_field(&test_class, "ran", "Z").await?; + let ran: bool = jvm.get_field(&test_class, "TestClass", "ran", "Z").await?; assert!(ran); assert!( @@ -121,7 +121,7 @@ async fn test_thread_cldc_metadata_and_state() -> Result<()> { let _: () = jvm .invoke_virtual(&thread, &thread.class_definition().name(), "interrupt", "()V", ()) .await?; - assert!(jvm.get_field::(&thread, "interrupted", "Z").await?); + assert!(jvm.get_field::(&thread, "java/lang/Thread", "interrupted", "Z").await?); assert!(jvm.invoke_static::<_, i32>("java/lang/Thread", "activeCount", "()I", ()).await? >= 1); let result: Result<()> = jvm @@ -239,7 +239,7 @@ async fn test_thread_jdk12_metadata_name_interrupt_and_daemon_state() -> Result< !jvm.invoke_virtual::<_, bool>(¤t, ¤t.class_definition().name(), "isInterrupted", "()Z", ()) .await? ); - assert!(!jvm.get_field::(¤t, "interrupted", "Z").await?); + assert!(!jvm.get_field::(¤t, "java/lang/Thread", "interrupted", "Z").await?); let result: Result<()> = jvm .invoke_virtual(&thread, &thread.class_definition().name(), "join", "(J)V", (-1i64,)) diff --git a/rustjava-runtime/tests/classes/java/util/jar/test_attributes.rs b/rustjava-runtime/tests/classes/java/util/jar/test_attributes.rs index 5f92b91e..800dfb2e 100644 --- a/rustjava-runtime/tests/classes/java/util/jar/test_attributes.rs +++ b/rustjava-runtime/tests/classes/java/util/jar/test_attributes.rs @@ -8,7 +8,7 @@ async fn test_attribute_get_set() -> Result<()> { let jvm = test_jvm().await?; let attributes = jvm.new_class("java/util/jar/Attributes", "()V", ()).await?; - let map: ClassInstanceRef = jvm.get_field(&attributes, "map", "Ljava/util/Map;").await?; + let map: ClassInstanceRef = jvm.get_field(&attributes, "java/util/jar/Attributes", "map", "Ljava/util/Map;").await?; assert!(!map.is_null()); assert!(jvm.is_instance(&**map, "java/util/HashMap")); assert!(jvm.is_instance(&**map, "java/util/Map")); diff --git a/rustjava-runtime/tests/classes/java/util/jar/test_jar_file.rs b/rustjava-runtime/tests/classes/java/util/jar/test_jar_file.rs index 2cbb9194..98b3aca1 100644 --- a/rustjava-runtime/tests/classes/java/util/jar/test_jar_file.rs +++ b/rustjava-runtime/tests/classes/java/util/jar/test_jar_file.rs @@ -64,7 +64,9 @@ async fn test_entries() -> Result<()> { let next_element: ClassInstanceRef = jvm .invoke_virtual(&entries, &entries.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ()) .await?; - let name = jvm.get_field(&next_element, "name", "Ljava/lang/String;").await?; + let name = jvm + .get_field(&next_element, "java/util/jar/JarEntry", "name", "Ljava/lang/String;") + .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "META-INF/"); let has_more_elements: bool = jvm @@ -74,7 +76,9 @@ async fn test_entries() -> Result<()> { let next_element: ClassInstanceRef = jvm .invoke_virtual(&entries, &entries.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ()) .await?; - let name = jvm.get_field(&next_element, "name", "Ljava/lang/String;").await?; + let name = jvm + .get_field(&next_element, "java/util/jar/JarEntry", "name", "Ljava/lang/String;") + .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "META-INF/MANIFEST.MF"); let has_more_elements: bool = jvm @@ -85,7 +89,9 @@ async fn test_entries() -> Result<()> { let next_element: ClassInstanceRef = jvm .invoke_virtual(&entries, &entries.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ()) .await?; - let name = jvm.get_field(&next_element, "name", "Ljava/lang/String;").await?; + let name = jvm + .get_field(&next_element, "java/util/jar/JarEntry", "name", "Ljava/lang/String;") + .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "JarTest.class"); let has_more_elements: bool = jvm @@ -96,7 +102,9 @@ async fn test_entries() -> Result<()> { let next_element: ClassInstanceRef = jvm .invoke_virtual(&entries, &entries.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ()) .await?; - let name = jvm.get_field(&next_element, "name", "Ljava/lang/String;").await?; + let name = jvm + .get_field(&next_element, "java/util/jar/JarEntry", "name", "Ljava/lang/String;") + .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "test.txt"); let has_more_elements: bool = jvm diff --git a/rustjava-runtime/tests/classes/java/util/logging/test_handlers.rs b/rustjava-runtime/tests/classes/java/util/logging/test_handlers.rs index a7a33f9a..c9a31ace 100644 --- a/rustjava-runtime/tests/classes/java/util/logging/test_handlers.rs +++ b/rustjava-runtime/tests/classes/java/util/logging/test_handlers.rs @@ -38,11 +38,11 @@ impl ConfigurableFilter { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, allowed: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "allowed", "Z", allowed).await + jvm.put_field(&mut this, "ConfigurableLoggingFilter", "allowed", "Z", allowed).await } async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - jvm.get_field(&this, "allowed", "Z").await + jvm.get_field(&this, "ConfigurableLoggingFilter", "allowed", "Z").await } } @@ -167,7 +167,8 @@ async fn simple_formatter_includes_throwable_stack_trace() -> Result<()> { [JavaLangString::from_rust_string(&jvm, "example.Test.run(Test.java:7)").await?], ) .await?; - jvm.put_field(&mut thrown, "stackTrace", "[Ljava/lang/String;", stack_trace).await?; + jvm.put_field(&mut thrown, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;", stack_trace) + .await?; let _: () = jvm .invoke_virtual(&record, "java/util/logging/LogRecord", "setThrown", "(Ljava/lang/Throwable;)V", (thrown,)) .await?; diff --git a/rustjava-runtime/tests/classes/java/util/regex/test_matcher.rs b/rustjava-runtime/tests/classes/java/util/regex/test_matcher.rs index 74008a5f..5f930fab 100644 --- a/rustjava-runtime/tests/classes/java/util/regex/test_matcher.rs +++ b/rustjava-runtime/tests/classes/java/util/regex/test_matcher.rs @@ -46,14 +46,15 @@ impl SnapshotFailingCharSequence { async fn init(jvm: &jvm::Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "lengthCalls", "I", 0).await?; - jvm.put_field(&mut this, "snapshotCalls", "I", 0).await?; - jvm.put_field(&mut this, "failSnapshot", "Z", true).await + jvm.put_field(&mut this, "SnapshotFailingCharSequence", "lengthCalls", "I", 0).await?; + jvm.put_field(&mut this, "SnapshotFailingCharSequence", "snapshotCalls", "I", 0).await?; + jvm.put_field(&mut this, "SnapshotFailingCharSequence", "failSnapshot", "Z", true).await } async fn length(jvm: &jvm::Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { - let calls: i32 = jvm.get_field(&this, "lengthCalls", "I").await?; - jvm.put_field(&mut this, "lengthCalls", "I", calls + 1).await?; + let calls: i32 = jvm.get_field(&this, "SnapshotFailingCharSequence", "lengthCalls", "I").await?; + jvm.put_field(&mut this, "SnapshotFailingCharSequence", "lengthCalls", "I", calls + 1) + .await?; Ok(1) } @@ -72,9 +73,10 @@ impl SnapshotFailingCharSequence { } async fn to_string(jvm: &jvm::Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "snapshotCalls", "I").await?; - jvm.put_field(&mut this, "snapshotCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "failSnapshot", "Z").await? { + let calls: i32 = jvm.get_field(&this, "SnapshotFailingCharSequence", "snapshotCalls", "I").await?; + jvm.put_field(&mut this, "SnapshotFailingCharSequence", "snapshotCalls", "I", calls + 1) + .await?; + if jvm.get_field::(&this, "SnapshotFailingCharSequence", "failSnapshot", "Z").await? { Err(jvm.exception("java/lang/IllegalStateException", "snapshot requested").await) } else { Ok(JavaLangString::from_rust_string(jvm, "a").await?.into()) @@ -711,16 +713,30 @@ async fn invalid_find_start_is_checked_before_creating_an_input_snapshot() -> Re panic!("negative find start must throw"); }; assert!(jvm.is_instance(&*exception, "java/lang/IndexOutOfBoundsException")); - assert_eq!(jvm.get_field::(&sequence, "lengthCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&sequence, "snapshotCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "lengthCalls", "I").await?, + 0 + ); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "snapshotCalls", "I") + .await?, + 0 + ); let result: Result = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "find", "(I)Z", (2,)).await; let Err(JavaError::JavaException(exception)) = result else { panic!("find start beyond the input length must throw"); }; assert!(jvm.is_instance(&*exception, "java/lang/IndexOutOfBoundsException")); - assert_eq!(jvm.get_field::(&sequence, "lengthCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&sequence, "snapshotCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "lengthCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "snapshotCalls", "I") + .await?, + 0 + ); Ok(()) } @@ -736,7 +752,8 @@ async fn valid_find_start_resets_state_before_creating_an_input_snapshot() -> Re jvm.register_class(class, None).await?; let mut sequence: ClassInstanceRef = jvm.new_class("SnapshotFailingCharSequence", "()V", ()).await?.into(); - jvm.put_field(&mut sequence, "failSnapshot", "Z", false).await?; + jvm.put_field(&mut sequence, "SnapshotFailingCharSequence", "failSnapshot", "Z", false) + .await?; let input: ClassInstanceRef = ClassInstanceRef::new(sequence.clone().instance); let source = JavaLangString::from_rust_string(&jvm, "a").await?; let pattern: ClassInstanceRef = jvm @@ -766,22 +783,30 @@ async fn valid_find_start_resets_state_before_creating_an_input_snapshot() -> Re 0 ); - jvm.put_field(&mut sequence, "failSnapshot", "Z", true).await?; + jvm.put_field(&mut sequence, "SnapshotFailingCharSequence", "failSnapshot", "Z", true) + .await?; let result: Result = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "find", "(I)Z", (0,)).await; let Err(JavaError::JavaException(exception)) = result else { panic!("snapshot failure must be observable"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&sequence, "lengthCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&sequence, "snapshotCalls", "I").await?, 2); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "lengthCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&sequence, "SnapshotFailingCharSequence", "snapshotCalls", "I") + .await?, + 2 + ); let result: Result = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "start", "()I", ()).await; let Err(JavaError::JavaException(exception)) = result else { panic!("valid find(start) must invalidate the previous match before searching"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&matcher, "searchPosition", "I").await?, 0); - assert_eq!(jvm.get_field::(&matcher, "appendPosition", "I").await?, 0); + assert_eq!(jvm.get_field::(&matcher, "java/util/regex/Matcher", "searchPosition", "I").await?, 0); + assert_eq!(jvm.get_field::(&matcher, "java/util/regex/Matcher", "appendPosition", "I").await?, 0); Ok(()) } diff --git a/rustjava-runtime/tests/classes/java/util/test_array_list.rs b/rustjava-runtime/tests/classes/java/util/test_array_list.rs index 409b2abb..fa0b8661 100644 --- a/rustjava-runtime/tests/classes/java/util/test_array_list.rs +++ b/rustjava-runtime/tests/classes/java/util/test_array_list.rs @@ -8,7 +8,9 @@ async fn test_array_list_basic_operations_and_capacity_zero() -> Result<()> { let jvm = test_jvm().await?; let array_list = jvm.new_class("java/util/ArrayList", "(I)V", (0,)).await?; - let element_data: ClassInstanceRef> = jvm.get_field(&array_list, "elementData", "[Ljava/lang/Object;").await?; + let element_data: ClassInstanceRef> = jvm + .get_field(&array_list, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;") + .await?; assert_eq!(jvm.array_length(&element_data).await?, 0); let first = JavaLangString::from_rust_string(&jvm, "first").await?; @@ -27,7 +29,9 @@ async fn test_array_list_basic_operations_and_capacity_zero() -> Result<()> { .await?; assert!(added); - let element_data: ClassInstanceRef> = jvm.get_field(&array_list, "elementData", "[Ljava/lang/Object;").await?; + let element_data: ClassInstanceRef> = jvm + .get_field(&array_list, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;") + .await?; assert!(jvm.array_length(&element_data).await? >= 1); let _: bool = jvm @@ -91,7 +95,9 @@ async fn test_array_list_basic_operations_and_capacity_zero() -> Result<()> { .await?; assert_eq!(size, 2); - let element_data: ClassInstanceRef> = jvm.get_field(&array_list, "elementData", "[Ljava/lang/Object;").await?; + let element_data: ClassInstanceRef> = jvm + .get_field(&array_list, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;") + .await?; let removed_tail_slot: ClassInstanceRef = jvm.load_array(&element_data, 2, 1).await?.into_iter().next().unwrap(); assert!(removed_tail_slot.is_null()); @@ -120,7 +126,9 @@ async fn test_array_list_basic_operations_and_capacity_zero() -> Result<()> { .await?; assert_eq!(jvm.array_length(&array).await?, 0); - let element_data: ClassInstanceRef> = jvm.get_field(&array_list, "elementData", "[Ljava/lang/Object;").await?; + let element_data: ClassInstanceRef> = jvm + .get_field(&array_list, "java/util/ArrayList", "elementData", "[Ljava/lang/Object;") + .await?; let cleared_slots: Vec> = jvm.load_array(&element_data, 0, 2).await?; assert!(cleared_slots[0].is_null()); assert!(cleared_slots[1].is_null()); diff --git a/rustjava-runtime/tests/classes/java/util/test_arrays.rs b/rustjava-runtime/tests/classes/java/util/test_arrays.rs index 2660622c..b2b437a9 100644 --- a/rustjava-runtime/tests/classes/java/util/test_arrays.rs +++ b/rustjava-runtime/tests/classes/java/util/test_arrays.rs @@ -31,9 +31,9 @@ impl ArraysSortValue { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, key: i32, id: i32, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "I", key).await?; - jvm.put_field(&mut this, "id", "I", id).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await + jvm.put_field(&mut this, "ArraysSortValue", "key", "I", key).await?; + jvm.put_field(&mut this, "ArraysSortValue", "id", "I", id).await?; + jvm.put_field(&mut this, "ArraysSortValue", "fail", "Z", fail).await } async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -43,13 +43,15 @@ impl ArraysSortValue { if !jvm.is_instance(other.as_ref(), "ArraysSortValue") { return Err(jvm.exception("java/lang/ClassCastException", "other").await); } - if jvm.get_field::(&this, "fail", "Z").await? || jvm.get_field::(&other, "fail", "Z").await? { + if jvm.get_field::(&this, "ArraysSortValue", "fail", "Z").await? + || jvm.get_field::(&other, "ArraysSortValue", "fail", "Z").await? + { return Err(jvm.exception("java/lang/IllegalStateException", "comparison failure").await); } Ok(jvm - .get_field::(&this, "key", "I") + .get_field::(&this, "ArraysSortValue", "key", "I") .await? - .cmp(&jvm.get_field::(&other, "key", "I").await?) as i32) + .cmp(&jvm.get_field::(&other, "ArraysSortValue", "key", "I").await?) as i32) } } @@ -80,8 +82,8 @@ impl ArraysComparator { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, reverse: bool, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "reverse", "Z", reverse).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await + jvm.put_field(&mut this, "ArraysComparator", "reverse", "Z", reverse).await?; + jvm.put_field(&mut this, "ArraysComparator", "fail", "Z", fail).await } async fn compare( @@ -91,17 +93,17 @@ impl ArraysComparator { left: ClassInstanceRef, right: ClassInstanceRef, ) -> Result { - if jvm.get_field::(&this, "fail", "Z").await? { + if jvm.get_field::(&this, "ArraysComparator", "fail", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "comparison failure").await); } if left.is_null() || right.is_null() { return Err(jvm.exception("java/lang/NullPointerException", "value").await); } let comparison = jvm - .get_field::(&left, "key", "I") + .get_field::(&left, "ArraysSortValue", "key", "I") .await? - .cmp(&jvm.get_field::(&right, "key", "I").await?) as i32; - Ok(if jvm.get_field::(&this, "reverse", "Z").await? { + .cmp(&jvm.get_field::(&right, "ArraysSortValue", "key", "I").await?) as i32; + Ok(if jvm.get_field::(&this, "ArraysComparator", "reverse", "Z").await? { -comparison } else { comparison @@ -128,11 +130,11 @@ impl ArraysEqualsProbe { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, result: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "result", "Z", result).await + jvm.put_field(&mut this, "ArraysEqualsProbe", "result", "Z", result).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - jvm.get_field(&this, "result", "Z").await + jvm.get_field(&this, "ArraysEqualsProbe", "result", "Z").await } } @@ -378,7 +380,7 @@ async fn test_arr_02_object_sort_is_stable_and_supports_all_modes() -> Result<() let sorted = jvm.load_array::>(&array, 0, 4).await?; let mut ids = vec![]; for value in sorted { - ids.push(jvm.get_field::(&value, "id", "I").await?); + ids.push(jvm.get_field::(&value, "ArraysSortValue", "id", "I").await?); } assert_eq!(ids, [1, 3, 0, 2]); @@ -399,8 +401,8 @@ async fn test_arr_02_object_sort_is_stable_and_supports_all_modes() -> Result<() .await?; let sorted = jvm.load_array::>(&range, 0, 4).await?; assert_eq!(sorted[0].identity(), outside_left.identity()); - assert_eq!(jvm.get_field::(&sorted[1], "key", "I").await?, 3); - assert_eq!(jvm.get_field::(&sorted[2], "key", "I").await?, 1); + assert_eq!(jvm.get_field::(&sorted[1], "ArraysSortValue", "key", "I").await?, 3); + assert_eq!(jvm.get_field::(&sorted[2], "ArraysSortValue", "key", "I").await?, 1); assert_eq!(sorted[3].identity(), outside_right.identity()); let null_comparator: ClassInstanceRef = None.into(); @@ -413,10 +415,10 @@ async fn test_arr_02_object_sort_is_stable_and_supports_all_modes() -> Result<() .await?; let sorted = jvm.load_array::>(&range, 0, 4).await?; let keys = [ - jvm.get_field::(&sorted[0], "key", "I").await?, - jvm.get_field::(&sorted[1], "key", "I").await?, - jvm.get_field::(&sorted[2], "key", "I").await?, - jvm.get_field::(&sorted[3], "key", "I").await?, + jvm.get_field::(&sorted[0], "ArraysSortValue", "key", "I").await?, + jvm.get_field::(&sorted[1], "ArraysSortValue", "key", "I").await?, + jvm.get_field::(&sorted[2], "ArraysSortValue", "key", "I").await?, + jvm.get_field::(&sorted[3], "ArraysSortValue", "key", "I").await?, ]; assert_eq!(keys, [-99, 1, 3, 99]); diff --git a/rustjava-runtime/tests/classes/java/util/test_collection_contracts.rs b/rustjava-runtime/tests/classes/java/util/test_collection_contracts.rs index 56cfd416..5ba159bc 100644 --- a/rustjava-runtime/tests/classes/java/util/test_collection_contracts.rs +++ b/rustjava-runtime/tests/classes/java/util/test_collection_contracts.rs @@ -28,16 +28,17 @@ impl SnapshotCollection { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, elements: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "", "()V", ()).await?; - jvm.put_field(&mut this, "elements", "[Ljava/lang/Object;", elements).await + jvm.put_field(&mut this, "SnapshotCollection", "elements", "[Ljava/lang/Object;", elements) + .await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "SnapshotCollection", "elements", "[Ljava/lang/Object;").await?; Ok(jvm.array_length(&elements).await? as i32) } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "SnapshotCollection", "elements", "[Ljava/lang/Object;").await?; Ok(jvm.new_class("SnapshotIterator", "([Ljava/lang/Object;)V", (elements,)).await?.into()) } } @@ -66,24 +67,25 @@ impl SnapshotIterator { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, elements: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "elements", "[Ljava/lang/Object;", elements).await?; - jvm.put_field(&mut this, "index", "I", 0).await + jvm.put_field(&mut this, "SnapshotIterator", "elements", "[Ljava/lang/Object;", elements) + .await?; + jvm.put_field(&mut this, "SnapshotIterator", "index", "I", 0).await } async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "SnapshotIterator", "elements", "[Ljava/lang/Object;").await?; + let index: i32 = jvm.get_field(&this, "SnapshotIterator", "index", "I").await?; Ok(index < jvm.array_length(&elements).await? as i32) } async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; - let index: i32 = jvm.get_field(&this, "index", "I").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "SnapshotIterator", "elements", "[Ljava/lang/Object;").await?; + let index: i32 = jvm.get_field(&this, "SnapshotIterator", "index", "I").await?; if index >= jvm.array_length(&elements).await? as i32 { return Err(jvm.exception("java/util/NoSuchElementException", "snapshot iterator exhausted").await); } let value = jvm.load_array::>(&elements, index as usize, 1).await?.remove(0); - jvm.put_field(&mut this, "index", "I", index + 1).await?; + jvm.put_field(&mut this, "SnapshotIterator", "index", "I", index + 1).await?; Ok(value) } @@ -178,14 +180,14 @@ impl ConfigurableEqualsValue { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, result: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "result", "Z", result).await?; - jvm.put_field(&mut this, "equalsCalls", "I", 0).await + jvm.put_field(&mut this, "ConfigurableEqualsValue", "result", "Z", result).await?; + jvm.put_field(&mut this, "ConfigurableEqualsValue", "equalsCalls", "I", 0).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - let calls: i32 = jvm.get_field(&this, "equalsCalls", "I").await?; - jvm.put_field(&mut this, "equalsCalls", "I", calls + 1).await?; - jvm.get_field(&this, "result", "Z").await + let calls: i32 = jvm.get_field(&this, "ConfigurableEqualsValue", "equalsCalls", "I").await?; + jvm.put_field(&mut this, "ConfigurableEqualsValue", "equalsCalls", "I", calls + 1).await?; + jvm.get_field(&this, "ConfigurableEqualsValue", "result", "Z").await } } @@ -235,34 +237,36 @@ impl StatefulMapEntry { mode: i32, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "firstKey", "Ljava/lang/Object;", first_key).await?; - jvm.put_field(&mut this, "laterKey", "Ljava/lang/Object;", later_key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "mode", "I", mode).await?; - jvm.put_field(&mut this, "keyCalls", "I", 0).await?; - jvm.put_field(&mut this, "valueCalls", "I", 0).await + jvm.put_field(&mut this, "StatefulMapEntry", "firstKey", "Ljava/lang/Object;", first_key) + .await?; + jvm.put_field(&mut this, "StatefulMapEntry", "laterKey", "Ljava/lang/Object;", later_key) + .await?; + jvm.put_field(&mut this, "StatefulMapEntry", "value", "Ljava/lang/Object;", value).await?; + jvm.put_field(&mut this, "StatefulMapEntry", "mode", "I", mode).await?; + jvm.put_field(&mut this, "StatefulMapEntry", "keyCalls", "I", 0).await?; + jvm.put_field(&mut this, "StatefulMapEntry", "valueCalls", "I", 0).await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "keyCalls", "I").await?; - jvm.put_field(&mut this, "keyCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "mode", "I").await? == 1 { + let calls: i32 = jvm.get_field(&this, "StatefulMapEntry", "keyCalls", "I").await?; + jvm.put_field(&mut this, "StatefulMapEntry", "keyCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "StatefulMapEntry", "mode", "I").await? == 1 { return Err(jvm.exception("java/lang/IllegalStateException", "getKey failure").await); } if calls == 0 { - jvm.get_field(&this, "firstKey", "Ljava/lang/Object;").await + jvm.get_field(&this, "StatefulMapEntry", "firstKey", "Ljava/lang/Object;").await } else { - jvm.get_field(&this, "laterKey", "Ljava/lang/Object;").await + jvm.get_field(&this, "StatefulMapEntry", "laterKey", "Ljava/lang/Object;").await } } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "valueCalls", "I").await?; - jvm.put_field(&mut this, "valueCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "mode", "I").await? == 2 { + let calls: i32 = jvm.get_field(&this, "StatefulMapEntry", "valueCalls", "I").await?; + jvm.put_field(&mut this, "StatefulMapEntry", "valueCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "StatefulMapEntry", "mode", "I").await? == 2 { return Err(jvm.exception("java/lang/IllegalStateException", "getValue failure").await); } - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "StatefulMapEntry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -271,8 +275,8 @@ impl StatefulMapEntry { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let previous: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let previous: ClassInstanceRef = jvm.get_field(&this, "StatefulMapEntry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "StatefulMapEntry", "value", "Ljava/lang/Object;", value).await?; Ok(previous) } } @@ -300,16 +304,16 @@ impl ThrowingMap { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, size: i32, mode: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "size", "I", size).await?; - jvm.put_field(&mut this, "mode", "I", mode).await + jvm.put_field(&mut this, "ThrowingMap", "size", "I", size).await?; + jvm.put_field(&mut this, "ThrowingMap", "mode", "I", mode).await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "size", "I").await + jvm.get_field(&this, "ThrowingMap", "size", "I").await } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: ClassInstanceRef) -> Result> { - if jvm.get_field::(&this, "mode", "I").await? == 0 { + if jvm.get_field::(&this, "ThrowingMap", "mode", "I").await? == 0 { Err(jvm.exception("java/lang/NullPointerException", "test map get failure").await) } else { Err(jvm.exception("java/lang/ClassCastException", "test map get failure").await) @@ -1770,8 +1774,11 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&asymmetric_contains, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&asymmetric_contains, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&asymmetric_contains, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&asymmetric_contains, "StatefulMapEntry", "valueCalls", "I").await?, + 0 + ); assert_eq!( jvm.invoke_virtual::<_, i32>(&asymmetric_key_map, &asymmetric_key_map.class_definition().name(), "size", "()I", ()) .await?, @@ -1796,8 +1803,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&asymmetric_remove, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&asymmetric_remove, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&asymmetric_remove, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&asymmetric_remove, "StatefulMapEntry", "valueCalls", "I").await?, 0); assert_eq!( jvm.invoke_virtual::<_, i32>(&asymmetric_key_map, &asymmetric_key_map.class_definition().name(), "size", "()I", ()) .await?, @@ -1884,8 +1891,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&null_key_contains, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&null_key_contains, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_key_contains, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_key_contains, "StatefulMapEntry", "valueCalls", "I").await?, 1); let null_key_remove: ClassInstanceRef = jvm .new_class( "StatefulMapEntry", @@ -1904,8 +1911,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&null_key_remove, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&null_key_remove, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_key_remove, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_key_remove, "StatefulMapEntry", "valueCalls", "I").await?, 1); assert_eq!( jvm.invoke_virtual::<_, i32>(&null_key_map, &null_key_map.class_definition().name(), "size", "()I", ()) .await?, @@ -1948,10 +1955,17 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store .await?, "{map_class} EntrySet.contains must use storedValue.equals(candidateValue)" ); - assert_eq!(jvm.get_field::(&contains_candidate, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&contains_candidate, "valueCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stored_value, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_value, "equalsCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&contains_candidate, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&contains_candidate, "StatefulMapEntry", "valueCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&stored_value, "ConfigurableEqualsValue", "equalsCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&candidate_value, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 0 + ); let remove_candidate: ClassInstanceRef = jvm .new_class( @@ -1972,10 +1986,17 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store .await?, "{map_class} EntrySet.remove must use storedValue.equals(candidateValue)" ); - assert_eq!(jvm.get_field::(&remove_candidate, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&remove_candidate, "valueCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stored_value, "equalsCalls", "I").await?, 2); - assert_eq!(jvm.get_field::(&candidate_value, "equalsCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&remove_candidate, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&remove_candidate, "StatefulMapEntry", "valueCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&stored_value, "ConfigurableEqualsValue", "equalsCalls", "I").await?, + 2 + ); + assert_eq!( + jvm.get_field::(&candidate_value, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 0 + ); assert_eq!( jvm.invoke_virtual::<_, i32>(&map, &map.class_definition().name(), "size", "()I", ()) .await?, @@ -2022,8 +2043,16 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&rejecting_stored, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&accepting_candidate, "equalsCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&rejecting_stored, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&accepting_candidate, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 0 + ); let stateful_map: ClassInstanceRef = jvm.new_class(map_class, "()V", ()).await?.into(); let first_key = JavaLangString::from_rust_string(&jvm, "first-key").await?; @@ -2073,8 +2102,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&alternating, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&alternating, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&alternating, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&alternating, "StatefulMapEntry", "valueCalls", "I").await?, 1); assert!( !jvm.invoke_virtual::<_, bool>( &stateful_map, @@ -2125,8 +2154,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&missing_contains, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&missing_contains, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&missing_contains, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&missing_contains, "StatefulMapEntry", "valueCalls", "I").await?, 0); let missing_remove: ClassInstanceRef = jvm .new_class( @@ -2146,8 +2175,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&missing_remove, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&missing_remove, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&missing_remove, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&missing_remove, "StatefulMapEntry", "valueCalls", "I").await?, 0); let throwing_key: ClassInstanceRef = jvm .new_class( @@ -2170,8 +2199,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store panic!("{map_class} EntrySet.contains must propagate getKey exceptions"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_key, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_key, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&throwing_key, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_key, "StatefulMapEntry", "valueCalls", "I").await?, 0); let throwing_remove_key: ClassInstanceRef = jvm .new_class( @@ -2194,8 +2223,11 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store panic!("{map_class} EntrySet.remove must propagate getKey exceptions"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_remove_key, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_remove_key, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&throwing_remove_key, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&throwing_remove_key, "StatefulMapEntry", "valueCalls", "I").await?, + 0 + ); let throwing_contains_value: ClassInstanceRef = jvm .new_class( @@ -2218,8 +2250,16 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store panic!("{map_class} EntrySet.contains must propagate getValue exceptions for a found key"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_contains_value, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_contains_value, "valueCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&throwing_contains_value, "StatefulMapEntry", "keyCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&throwing_contains_value, "StatefulMapEntry", "valueCalls", "I") + .await?, + 1 + ); let throwing_value: ClassInstanceRef = jvm .new_class( @@ -2242,8 +2282,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store panic!("{map_class} EntrySet.remove must propagate getValue exceptions for a found key"); }; assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_value, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_value, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_value, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_value, "StatefulMapEntry", "valueCalls", "I").await?, 1); assert!( jvm.invoke_virtual::<_, bool>( &stateful_map, @@ -2308,8 +2348,8 @@ async fn coll_08_entry_set_contains_and_remove_snapshot_candidates_and_use_store ) .await? ); - assert_eq!(jvm.get_field::(&null_key, "keyCalls", "I").await?, 2); - assert_eq!(jvm.get_field::(&null_key, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&null_key, "StatefulMapEntry", "keyCalls", "I").await?, 2); + assert_eq!(jvm.get_field::(&null_key, "StatefulMapEntry", "valueCalls", "I").await?, 0); } } @@ -2538,8 +2578,8 @@ async fn hashtable_entry_equals_and_hash_code_follow_map_entry_contract() -> Res ) .await? ); - assert_eq!(jvm.get_field::(&short_circuit, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&short_circuit, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&short_circuit, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&short_circuit, "StatefulMapEntry", "valueCalls", "I").await?, 0); let throwing_key: ClassInstanceRef = jvm .new_class( @@ -2562,8 +2602,8 @@ async fn hashtable_entry_equals_and_hash_code_follow_map_entry_contract() -> Res panic!("Hashtable.Entry.equals must propagate getKey exceptions"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_key, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_key, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&throwing_key, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_key, "StatefulMapEntry", "valueCalls", "I").await?, 0); let throwing_value: ClassInstanceRef = jvm .new_class( @@ -2586,8 +2626,8 @@ async fn hashtable_entry_equals_and_hash_code_follow_map_entry_contract() -> Res panic!("Hashtable.Entry.equals must propagate getValue exceptions after matching keys"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_value, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_value, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_value, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_value, "StatefulMapEntry", "valueCalls", "I").await?, 1); let directional_table: ClassInstanceRef = jvm.new_class("java/util/Hashtable", "()V", ()).await?.into(); let stored_key: ClassInstanceRef = jvm.new_class("ConfigurableEqualsValue", "(Z)V", (true,)).await?.into(); @@ -2648,12 +2688,30 @@ async fn hashtable_entry_equals_and_hash_code_follow_map_entry_contract() -> Res ) .await? ); - assert_eq!(jvm.get_field::(&directional_candidate, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&directional_candidate, "valueCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&stored_key, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_key, "equalsCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&stored_value, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_value, "equalsCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&directional_candidate, "StatefulMapEntry", "keyCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&directional_candidate, "StatefulMapEntry", "valueCalls", "I") + .await?, + 1 + ); + assert_eq!(jvm.get_field::(&stored_key, "ConfigurableEqualsValue", "equalsCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&candidate_key, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 0 + ); + assert_eq!( + jvm.get_field::(&stored_value, "ConfigurableEqualsValue", "equalsCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&candidate_value, "ConfigurableEqualsValue", "equalsCalls", "I") + .await?, + 0 + ); let integer_key: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (7,)).await?.into(); let integer_value: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (11,)).await?.into(); @@ -2698,8 +2756,8 @@ async fn hashtable_entry_equals_and_hash_code_follow_map_entry_contract() -> Res ) .await? ); - assert_eq!(jvm.get_field::(&null_candidate, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&null_candidate, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_candidate, "StatefulMapEntry", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&null_candidate, "StatefulMapEntry", "valueCalls", "I").await?, 1); assert_eq!( jvm.invoke_virtual::<_, i32>(&null_entry, &null_entry.class_definition().name(), "hashCode", "()I", ()) .await?, diff --git a/rustjava-runtime/tests/classes/java/util/test_collections.rs b/rustjava-runtime/tests/classes/java/util/test_collections.rs index 632c7fa6..f7f1d490 100644 --- a/rustjava-runtime/tests/classes/java/util/test_collections.rs +++ b/rustjava-runtime/tests/classes/java/util/test_collections.rs @@ -31,9 +31,9 @@ impl CollectionsSortValue { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, key: i32, id: i32, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "I", key).await?; - jvm.put_field(&mut this, "id", "I", id).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await + jvm.put_field(&mut this, "CollectionsSortValue", "key", "I", key).await?; + jvm.put_field(&mut this, "CollectionsSortValue", "id", "I", id).await?; + jvm.put_field(&mut this, "CollectionsSortValue", "fail", "Z", fail).await } async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { @@ -43,14 +43,16 @@ impl CollectionsSortValue { if !jvm.is_instance(other.as_ref(), "CollectionsSortValue") { return Err(jvm.exception("java/lang/ClassCastException", "other").await); } - if jvm.get_field::(&this, "fail", "Z").await? || jvm.get_field::(&other, "fail", "Z").await? { + if jvm.get_field::(&this, "CollectionsSortValue", "fail", "Z").await? + || jvm.get_field::(&other, "CollectionsSortValue", "fail", "Z").await? + { return Err(jvm.exception("java/lang/IllegalStateException", "comparison failure").await); } Ok(jvm - .get_field::(&this, "key", "I") + .get_field::(&this, "CollectionsSortValue", "key", "I") .await? - .cmp(&jvm.get_field::(&other, "key", "I").await?) as i32) + .cmp(&jvm.get_field::(&other, "CollectionsSortValue", "key", "I").await?) as i32) } } @@ -83,9 +85,9 @@ impl CollectionsComparator { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, reverse: bool, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "reverse", "Z", reverse).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await?; - jvm.put_field(&mut this, "allowNull", "Z", false).await + jvm.put_field(&mut this, "CollectionsComparator", "reverse", "Z", reverse).await?; + jvm.put_field(&mut this, "CollectionsComparator", "fail", "Z", fail).await?; + jvm.put_field(&mut this, "CollectionsComparator", "allowNull", "Z", false).await } async fn init_with_nulls( @@ -97,9 +99,9 @@ impl CollectionsComparator { allow_null: bool, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "reverse", "Z", reverse).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await?; - jvm.put_field(&mut this, "allowNull", "Z", allow_null).await + jvm.put_field(&mut this, "CollectionsComparator", "reverse", "Z", reverse).await?; + jvm.put_field(&mut this, "CollectionsComparator", "fail", "Z", fail).await?; + jvm.put_field(&mut this, "CollectionsComparator", "allowNull", "Z", allow_null).await } async fn compare( @@ -109,11 +111,11 @@ impl CollectionsComparator { left: ClassInstanceRef, right: ClassInstanceRef, ) -> Result { - if jvm.get_field::(&this, "fail", "Z").await? { + if jvm.get_field::(&this, "CollectionsComparator", "fail", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "comparison failure").await); } let comparison = if left.is_null() || right.is_null() { - if !jvm.get_field::(&this, "allowNull", "Z").await? { + if !jvm.get_field::(&this, "CollectionsComparator", "allowNull", "Z").await? { return Err(jvm.exception("java/lang/NullPointerException", "value").await); } match (left.is_null(), right.is_null()) { @@ -123,11 +125,11 @@ impl CollectionsComparator { (false, false) => unreachable!(), } } else { - jvm.get_field::(&left, "key", "I") + jvm.get_field::(&left, "CollectionsSortValue", "key", "I") .await? - .cmp(&jvm.get_field::(&right, "key", "I").await?) as i32 + .cmp(&jvm.get_field::(&right, "CollectionsSortValue", "key", "I").await?) as i32 }; - Ok(if jvm.get_field::(&this, "reverse", "Z").await? { + Ok(if jvm.get_field::(&this, "CollectionsComparator", "reverse", "Z").await? { -comparison } else { comparison @@ -172,18 +174,19 @@ impl CollectionsProbeList { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, elements: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "", "()V", ()).await?; - jvm.put_field(&mut this, "elements", "[Ljava/lang/Object;", elements).await?; - jvm.put_field(&mut this, "listIteratorCalls", "I", 0).await?; - jvm.put_field(&mut this, "setCalls", "I", 0).await + jvm.put_field(&mut this, "CollectionsProbeList", "elements", "[Ljava/lang/Object;", elements) + .await?; + jvm.put_field(&mut this, "CollectionsProbeList", "listIteratorCalls", "I", 0).await?; + jvm.put_field(&mut this, "CollectionsProbeList", "setCalls", "I", 0).await } async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "CollectionsProbeList", "elements", "[Ljava/lang/Object;").await?; Ok(jvm.array_length(&elements).await? as i32) } async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, index: i32) -> Result> { - let elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; + let elements: ClassInstanceRef> = jvm.get_field(&this, "CollectionsProbeList", "elements", "[Ljava/lang/Object;").await?; let length = jvm.array_length(&elements).await? as i32; if index < 0 || index >= length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await); @@ -203,7 +206,7 @@ impl CollectionsProbeList { index: i32, element: ClassInstanceRef, ) -> Result> { - let mut elements: ClassInstanceRef> = jvm.get_field(&this, "elements", "[Ljava/lang/Object;").await?; + let mut elements: ClassInstanceRef> = jvm.get_field(&this, "CollectionsProbeList", "elements", "[Ljava/lang/Object;").await?; let length = jvm.array_length(&elements).await? as i32; if index < 0 || index >= length { return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await); @@ -215,21 +218,23 @@ impl CollectionsProbeList { .next() .unwrap(); jvm.store_array(&mut elements, index as usize, core::iter::once(element)).await?; - let calls: i32 = jvm.get_field(&this, "setCalls", "I").await?; - jvm.put_field(&mut this, "setCalls", "I", calls + 1).await?; + let calls: i32 = jvm.get_field(&this, "CollectionsProbeList", "setCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsProbeList", "setCalls", "I", calls + 1).await?; Ok(previous) } async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "listIteratorCalls", "I").await?; - jvm.put_field(&mut this, "listIteratorCalls", "I", calls + 1).await?; + let calls: i32 = jvm.get_field(&this, "CollectionsProbeList", "listIteratorCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsProbeList", "listIteratorCalls", "I", calls + 1) + .await?; jvm.invoke_special(&this, "java/util/AbstractList", "listIterator", "()Ljava/util/ListIterator;", ()) .await } async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, index: i32) -> Result> { - let calls: i32 = jvm.get_field(&this, "listIteratorCalls", "I").await?; - jvm.put_field(&mut this, "listIteratorCalls", "I", calls + 1).await?; + let calls: i32 = jvm.get_field(&this, "CollectionsProbeList", "listIteratorCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsProbeList", "listIteratorCalls", "I", calls + 1) + .await?; jvm.invoke_special(&this, "java/util/AbstractList", "listIterator", "(I)Ljava/util/ListIterator;", (index,)) .await } @@ -254,11 +259,11 @@ impl CollectionsInvalidRandom { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, result: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/Random", "", "(J)V", (0i64,)).await?; - jvm.put_field(&mut this, "result", "I", result).await + jvm.put_field(&mut this, "CollectionsInvalidRandom", "result", "I", result).await } async fn next_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: i32) -> Result { - jvm.get_field(&this, "result", "I").await + jvm.get_field(&this, "CollectionsInvalidRandom", "result", "I").await } } @@ -286,8 +291,9 @@ impl CollectionsExceptionalSet { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, element: ClassInstanceRef, mode: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "", "()V", ()).await?; - jvm.put_field(&mut this, "element", "Ljava/lang/Object;", element).await?; - jvm.put_field(&mut this, "mode", "I", mode).await + jvm.put_field(&mut this, "CollectionsExceptionalSet", "element", "Ljava/lang/Object;", element) + .await?; + jvm.put_field(&mut this, "CollectionsExceptionalSet", "mode", "I", mode).await } async fn size(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef) -> Result { @@ -295,7 +301,7 @@ impl CollectionsExceptionalSet { } async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm.get_field(&this, "CollectionsExceptionalSet", "element", "Ljava/lang/Object;").await?; let list = jvm .new_class("java/util/Collections$CopiesList", "(ILjava/lang/Object;)V", (1, element)) .await?; @@ -304,12 +310,12 @@ impl CollectionsExceptionalSet { } async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, target: ClassInstanceRef) -> Result { - match jvm.get_field::(&this, "mode", "I").await? { + match jvm.get_field::(&this, "CollectionsExceptionalSet", "mode", "I").await? { 0 => Err(jvm.exception("java/lang/ClassCastException", "incompatible element").await), 1 if target.is_null() => Err(jvm.exception("java/lang/NullPointerException", "null element").await), 2 => Err(jvm.exception("java/lang/IllegalStateException", "unexpected contains failure").await), _ => { - let element: ClassInstanceRef = jvm.get_field(&this, "element", "Ljava/lang/Object;").await?; + let element: ClassInstanceRef = jvm.get_field(&this, "CollectionsExceptionalSet", "element", "Ljava/lang/Object;").await?; if element.is_null() { Ok(target.is_null()) } else if target.is_null() { @@ -342,11 +348,11 @@ impl CollectionsAsymmetricEquals { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, result: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "result", "Z", result).await + jvm.put_field(&mut this, "CollectionsAsymmetricEquals", "result", "Z", result).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - jvm.get_field(&this, "result", "Z").await + jvm.get_field(&this, "CollectionsAsymmetricEquals", "result", "Z").await } } @@ -373,18 +379,18 @@ impl CollectionsEqualsProbe { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, result: bool, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "result", "Z", result).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await?; - jvm.put_field(&mut this, "equalsCalls", "I", 0).await + jvm.put_field(&mut this, "CollectionsEqualsProbe", "result", "Z", result).await?; + jvm.put_field(&mut this, "CollectionsEqualsProbe", "fail", "Z", fail).await?; + jvm.put_field(&mut this, "CollectionsEqualsProbe", "equalsCalls", "I", 0).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - let calls: i32 = jvm.get_field(&this, "equalsCalls", "I").await?; - jvm.put_field(&mut this, "equalsCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "fail", "Z").await? { + let calls: i32 = jvm.get_field(&this, "CollectionsEqualsProbe", "equalsCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsEqualsProbe", "equalsCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "CollectionsEqualsProbe", "fail", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "equals failure").await); } - jvm.get_field(&this, "result", "Z").await + jvm.get_field(&this, "CollectionsEqualsProbe", "result", "Z").await } } @@ -435,31 +441,33 @@ impl CollectionsEntryProbe { throw_value: bool, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "throwKey", "Z", throw_key).await?; - jvm.put_field(&mut this, "throwValue", "Z", throw_value).await?; - jvm.put_field(&mut this, "keyCalls", "I", 0).await?; - jvm.put_field(&mut this, "valueCalls", "I", 0).await?; - jvm.put_field(&mut this, "setValueCalls", "I", 0).await + jvm.put_field(&mut this, "CollectionsEntryProbe", "key", "Ljava/lang/Object;", key) + .await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "value", "Ljava/lang/Object;", value) + .await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "throwKey", "Z", throw_key).await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "throwValue", "Z", throw_value).await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "keyCalls", "I", 0).await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "valueCalls", "I", 0).await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "setValueCalls", "I", 0).await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "keyCalls", "I").await?; - jvm.put_field(&mut this, "keyCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "throwKey", "Z").await? { + let calls: i32 = jvm.get_field(&this, "CollectionsEntryProbe", "keyCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "keyCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "CollectionsEntryProbe", "throwKey", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "getKey failure").await); } - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "CollectionsEntryProbe", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "valueCalls", "I").await?; - jvm.put_field(&mut this, "valueCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "throwValue", "Z").await? { + let calls: i32 = jvm.get_field(&this, "CollectionsEntryProbe", "valueCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "valueCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "CollectionsEntryProbe", "throwValue", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "getValue failure").await); } - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "CollectionsEntryProbe", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -468,10 +476,11 @@ impl CollectionsEntryProbe { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let calls: i32 = jvm.get_field(&this, "setValueCalls", "I").await?; - jvm.put_field(&mut this, "setValueCalls", "I", calls + 1).await?; - let previous: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let calls: i32 = jvm.get_field(&this, "CollectionsEntryProbe", "setValueCalls", "I").await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "setValueCalls", "I", calls + 1).await?; + let previous: ClassInstanceRef = jvm.get_field(&this, "CollectionsEntryProbe", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "CollectionsEntryProbe", "value", "Ljava/lang/Object;", value) + .await?; Ok(previous) } } @@ -660,18 +669,18 @@ async fn test_coll_02_stable_sort_and_comparator_failure_is_atomic() -> Result<( jvm.invoke_static::<_, ()>("java/util/Collections", "sort", "(Ljava/util/List;)V", (list.clone(),)) .await?; - let sorted: ClassInstanceRef> = jvm.get_field(&list, "elements", "[Ljava/lang/Object;").await?; + let sorted: ClassInstanceRef> = jvm.get_field(&list, "CollectionsProbeList", "elements", "[Ljava/lang/Object;").await?; let sorted = jvm.load_array::>(&sorted, 0, 4).await?; let mut keys_and_ids = vec![]; for value in sorted { keys_and_ids.push(( - jvm.get_field::(&value, "key", "I").await?, - jvm.get_field::(&value, "id", "I").await?, + jvm.get_field::(&value, "CollectionsSortValue", "key", "I").await?, + jvm.get_field::(&value, "CollectionsSortValue", "id", "I").await?, )); } assert_eq!(keys_and_ids, vec![(1, 1), (1, 3), (2, 0), (2, 2)]); - assert_eq!(jvm.get_field::(&list, "listIteratorCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&list, "setCalls", "I").await?, 4); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "listIteratorCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "setCalls", "I").await?, 4); let reverse: ClassInstanceRef = jvm.new_class("CollectionsComparator", "(ZZ)V", (true, false)).await?.into(); jvm.invoke_static::<_, ()>( @@ -681,13 +690,13 @@ async fn test_coll_02_stable_sort_and_comparator_failure_is_atomic() -> Result<( (list.clone(), reverse), ) .await?; - let reverse_sorted: ClassInstanceRef> = jvm.get_field(&list, "elements", "[Ljava/lang/Object;").await?; + let reverse_sorted: ClassInstanceRef> = jvm.get_field(&list, "CollectionsProbeList", "elements", "[Ljava/lang/Object;").await?; let reverse_sorted = jvm.load_array::>(&reverse_sorted, 0, 4).await?; let mut reverse_keys_and_ids = vec![]; for value in reverse_sorted { reverse_keys_and_ids.push(( - jvm.get_field::(&value, "key", "I").await?, - jvm.get_field::(&value, "id", "I").await?, + jvm.get_field::(&value, "CollectionsSortValue", "key", "I").await?, + jvm.get_field::(&value, "CollectionsSortValue", "id", "I").await?, )); } assert_eq!(reverse_keys_and_ids, vec![(2, 0), (2, 2), (1, 1), (1, 3)]); @@ -716,14 +725,20 @@ async fn test_coll_02_stable_sort_and_comparator_failure_is_atomic() -> Result<( panic!("failing comparator must propagate"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - let after: ClassInstanceRef> = jvm.get_field(&failing_list, "elements", "[Ljava/lang/Object;").await?; + let after: ClassInstanceRef> = jvm + .get_field(&failing_list, "CollectionsProbeList", "elements", "[Ljava/lang/Object;") + .await?; let after = jvm.load_array::>(&after, 0, 3).await?; assert_eq!( after.iter().map(|element| element.identity()).collect::>(), failing_original.iter().map(|element| element.identity()).collect::>() ); - assert_eq!(jvm.get_field::(&failing_list, "listIteratorCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&failing_list, "setCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&failing_list, "CollectionsProbeList", "listIteratorCalls", "I") + .await?, + 0 + ); + assert_eq!(jvm.get_field::(&failing_list, "CollectionsProbeList", "setCalls", "I").await?, 0); Ok(()) } @@ -812,8 +827,8 @@ async fn test_coll_04_reverse_fill_copy_use_list_iterator_and_validate_destinati jvm.invoke_static::<_, ()>("java/util/Collections", "reverse", "(Ljava/util/List;)V", (list.clone(),)) .await?; assert_eq!(integer_values(&jvm, &list).await?, vec![4, 3, 2, 1]); - assert_eq!(jvm.get_field::(&list, "listIteratorCalls", "I").await?, 2); - assert_eq!(jvm.get_field::(&list, "setCalls", "I").await?, 4); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "listIteratorCalls", "I").await?, 2); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "setCalls", "I").await?, 4); let fill_value: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (7,)).await?.into(); jvm.invoke_static::<_, ()>( @@ -824,7 +839,7 @@ async fn test_coll_04_reverse_fill_copy_use_list_iterator_and_validate_destinati ) .await?; assert_eq!(integer_values(&jvm, &list).await?, vec![7, 7, 7, 7]); - assert_eq!(jvm.get_field::(&list, "listIteratorCalls", "I").await?, 3); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "listIteratorCalls", "I").await?, 3); let source = integer_list(&jvm, &[8, 9]).await?; jvm.invoke_static::<_, ()>( @@ -835,7 +850,7 @@ async fn test_coll_04_reverse_fill_copy_use_list_iterator_and_validate_destinati ) .await?; assert_eq!(integer_values(&jvm, &list).await?, vec![8, 9, 7, 7]); - assert_eq!(jvm.get_field::(&list, "listIteratorCalls", "I").await?, 4); + assert_eq!(jvm.get_field::(&list, "CollectionsProbeList", "listIteratorCalls", "I").await?, 4); let odd = integer_list(&jvm, &[1, 2, 3, 4, 5]).await?; jvm.invoke_static::<_, ()>("java/util/Collections", "reverse", "(Ljava/util/List;)V", (odd.clone(),)) @@ -1008,8 +1023,8 @@ async fn test_coll_06_min_max_natural_comparator_empty_and_null() -> Result<()> (comparable_values, reverse), ) .await?; - assert_eq!(jvm.get_field::(&comparator_min, "key", "I").await?, 3); - assert_eq!(jvm.get_field::(&comparator_max, "key", "I").await?, 1); + assert_eq!(jvm.get_field::(&comparator_min, "CollectionsSortValue", "key", "I").await?, 3); + assert_eq!(jvm.get_field::(&comparator_max, "CollectionsSortValue", "key", "I").await?, 1); let empty = integer_list(&jvm, &[]).await?; for name in ["min", "max"] { @@ -3227,12 +3242,21 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi ) .await? ); - assert_eq!(jvm.get_field::(&backing_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing_entry, "valueCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&candidate_entry, "valueCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&rejecting_key, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_key, "equalsCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&backing_entry, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&candidate_entry, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing_entry, "CollectionsEntryProbe", "valueCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&candidate_entry, "CollectionsEntryProbe", "valueCalls", "I").await?, + 0 + ); + assert_eq!( + jvm.get_field::(&rejecting_key, "CollectionsEqualsProbe", "equalsCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&candidate_key, "CollectionsEqualsProbe", "equalsCalls", "I").await?, + 0 + ); let accepting_key: ClassInstanceRef = jvm.new_class("CollectionsEqualsProbe", "(ZZ)V", (true, false)).await?.into(); let accepting_value: ClassInstanceRef = jvm.new_class("CollectionsEqualsProbe", "(ZZ)V", (true, false)).await?.into(); @@ -3272,14 +3296,32 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi ) .await? ); - assert_eq!(jvm.get_field::(&backing_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&backing_entry, "valueCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&candidate_entry, "valueCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&accepting_key, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&accepting_value, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&reverse_direction_key, "equalsCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&reverse_direction_value, "equalsCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&backing_entry, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&backing_entry, "CollectionsEntryProbe", "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&candidate_entry, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&candidate_entry, "CollectionsEntryProbe", "valueCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&accepting_key, "CollectionsEqualsProbe", "equalsCalls", "I").await?, + 1 + ); + assert_eq!( + jvm.get_field::(&accepting_value, "CollectionsEqualsProbe", "equalsCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&reverse_direction_key, "CollectionsEqualsProbe", "equalsCalls", "I") + .await?, + 0 + ); + assert_eq!( + jvm.get_field::(&reverse_direction_value, "CollectionsEqualsProbe", "equalsCalls", "I") + .await?, + 0 + ); let replacement: ClassInstanceRef = jvm.new_class("java/lang/Object", "()V", ()).await?.into(); let result: Result> = jvm @@ -3295,7 +3337,11 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("wrapped custom entry.setValue must throw"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/UnsupportedOperationException")); - assert_eq!(jvm.get_field::(&backing_entry, "setValueCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&backing_entry, "CollectionsEntryProbe", "setValueCalls", "I") + .await?, + 0 + ); let throwing_key_entry: ClassInstanceRef = jvm .new_class( @@ -3334,8 +3380,16 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("backing getKey exception must propagate"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_key_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&untouched_candidate, "keyCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&throwing_key_entry, "CollectionsEntryProbe", "keyCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&untouched_candidate, "CollectionsEntryProbe", "keyCalls", "I") + .await?, + 0 + ); let throwing_equals_key: ClassInstanceRef = jvm.new_class("CollectionsEqualsProbe", "(ZZ)V", (true, true)).await?.into(); let throwing_equals_entry: ClassInstanceRef = jvm @@ -3367,8 +3421,16 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("backing key.equals exception must propagate"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_equals_key, "equalsCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_equals_entry, "valueCalls", "I").await?, 0); + assert_eq!( + jvm.get_field::(&throwing_equals_key, "CollectionsEqualsProbe", "equalsCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&throwing_equals_entry, "CollectionsEntryProbe", "valueCalls", "I") + .await?, + 0 + ); let required_throwing_value_entry: ClassInstanceRef = jvm .new_class( @@ -3391,8 +3453,16 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("candidate getValue exception must propagate after equal keys"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&required_throwing_value_entry, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&required_throwing_value_entry, "valueCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&required_throwing_value_entry, "CollectionsEntryProbe", "keyCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&required_throwing_value_entry, "CollectionsEntryProbe", "valueCalls", "I") + .await?, + 1 + ); let map: ClassInstanceRef = jvm.new_class("java/util/HashMap", "()V", ()).await?.into(); let map_key: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (7,)).await?.into(); @@ -3430,8 +3500,8 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi ) .await? ); - assert_eq!(jvm.get_field::(&matching, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&matching, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&matching, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&matching, "CollectionsEntryProbe", "valueCalls", "I").await?, 1); let missing_key: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (8,)).await?.into(); let null: ClassInstanceRef = None.into(); @@ -3453,8 +3523,8 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi ) .await? ); - assert_eq!(jvm.get_field::(&missing, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&missing, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&missing, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&missing, "CollectionsEntryProbe", "valueCalls", "I").await?, 0); let existing_key: ClassInstanceRef = jvm.new_class("java/lang/Integer", "(I)V", (7,)).await?.into(); let required_throwing_value: ClassInstanceRef = jvm @@ -3478,8 +3548,16 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("contains must propagate getValue failure after finding the key"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&required_throwing_value, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&required_throwing_value, "valueCalls", "I").await?, 1); + assert_eq!( + jvm.get_field::(&required_throwing_value, "CollectionsEntryProbe", "keyCalls", "I") + .await?, + 1 + ); + assert_eq!( + jvm.get_field::(&required_throwing_value, "CollectionsEntryProbe", "valueCalls", "I") + .await?, + 1 + ); let throwing_key: ClassInstanceRef = jvm .new_class( @@ -3502,8 +3580,8 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi panic!("contains must propagate getKey failure"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&throwing_key, "keyCalls", "I").await?, 1); - assert_eq!(jvm.get_field::(&throwing_key, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&throwing_key, "CollectionsEntryProbe", "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&throwing_key, "CollectionsEntryProbe", "valueCalls", "I").await?, 0); let never_reached: ClassInstanceRef = jvm .new_class( @@ -3551,8 +3629,8 @@ async fn test_coll_08_unmodifiable_entry_equals_and_contains_preserve_jdk_orderi ) .await? ); - assert_eq!(jvm.get_field::(&never_reached, "keyCalls", "I").await?, 0); - assert_eq!(jvm.get_field::(&never_reached, "valueCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&never_reached, "CollectionsEntryProbe", "keyCalls", "I").await?, 0); + assert_eq!(jvm.get_field::(&never_reached, "CollectionsEntryProbe", "valueCalls", "I").await?, 0); Ok(()) } @@ -4220,7 +4298,7 @@ async fn test_coll_08_unmodifiable_sorted_ranges_preserve_custom_comparator_boun .await? ); - jvm.put_field(&mut comparator.clone(), "fail", "Z", true).await?; + jvm.put_field(&mut comparator.clone(), "CollectionsComparator", "fail", "Z", true).await?; let result: Result> = jvm .invoke_virtual( &map_range, @@ -4247,7 +4325,8 @@ async fn test_coll_08_unmodifiable_sorted_ranges_preserve_custom_comparator_boun panic!("unmodifiable map mutation must throw before comparator range validation"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/UnsupportedOperationException")); - jvm.put_field(&mut comparator.clone(), "fail", "Z", false).await?; + jvm.put_field(&mut comparator.clone(), "CollectionsComparator", "fail", "Z", false) + .await?; let set: ClassInstanceRef = jvm .new_class("java/util/TreeSet", "(Ljava/util/Comparator;)V", (comparator.clone(),)) @@ -4414,7 +4493,7 @@ async fn test_coll_08_unmodifiable_sorted_ranges_preserve_custom_comparator_boun .await? ); - jvm.put_field(&mut comparator.clone(), "fail", "Z", true).await?; + jvm.put_field(&mut comparator.clone(), "CollectionsComparator", "fail", "Z", true).await?; let result: Result> = jvm .invoke_virtual( &set_range, diff --git a/rustjava-runtime/tests/classes/java/util/test_hash_map.rs b/rustjava-runtime/tests/classes/java/util/test_hash_map.rs index d803af61..48f34028 100644 --- a/rustjava-runtime/tests/classes/java/util/test_hash_map.rs +++ b/rustjava-runtime/tests/classes/java/util/test_hash_map.rs @@ -98,7 +98,7 @@ impl CollisionKey { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, id: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "id", "I", id).await?; + jvm.put_field(&mut this, "HashMapCollisionKey", "id", "I", id).await?; Ok(()) } @@ -112,8 +112,8 @@ impl CollisionKey { return Ok(false); } - let this_id: i32 = jvm.get_field(&this, "id", "I").await?; - let other_id: i32 = jvm.get_field(&other, "id", "I").await?; + let this_id: i32 = jvm.get_field(&this, "HashMapCollisionKey", "id", "I").await?; + let other_id: i32 = jvm.get_field(&other, "HashMapCollisionKey", "id", "I").await?; Ok(this_id == other_id) } @@ -154,18 +154,18 @@ impl CustomMapEntry { value: ClassInstanceRef, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + jvm.put_field(&mut this, "CustomMapEntry", "key", "Ljava/lang/Object;", key).await?; + jvm.put_field(&mut this, "CustomMapEntry", "value", "Ljava/lang/Object;", value).await?; Ok(()) } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "CustomMapEntry", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "CustomMapEntry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -174,8 +174,8 @@ impl CustomMapEntry { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let old_value: ClassInstanceRef = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old_value: ClassInstanceRef = jvm.get_field(&this, "CustomMapEntry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "CustomMapEntry", "value", "Ljava/lang/Object;", value).await?; Ok(old_value) } @@ -689,7 +689,9 @@ async fn test_hash_map_zero_and_negative_capacity() -> Result<()> { let jvm = test_jvm().await?; let hash_map = jvm.new_class("java/util/HashMap", "(I)V", (0,)).await?; - let table: ClassInstanceRef> = jvm.get_field(&hash_map, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&hash_map, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;") + .await?; assert_eq!(jvm.array_length(&table).await?, 0); let key = JavaLangString::from_rust_string(&jvm, "zero-key").await?; @@ -717,7 +719,9 @@ async fn test_hash_map_zero_and_negative_capacity() -> Result<()> { .await?; assert!(old.is_null()); - let table: ClassInstanceRef> = jvm.get_field(&hash_map, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&hash_map, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;") + .await?; assert!(jvm.array_length(&table).await? >= 1); let found: ClassInstanceRef = jvm @@ -877,7 +881,9 @@ async fn test_hash_map_clear_removes_entries_and_bucket_chains() -> Result<()> { .await?; assert!(!contains_value); - let table: ClassInstanceRef> = jvm.get_field(&hash_map, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm + .get_field(&hash_map, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;") + .await?; let table_len = jvm.array_length(&table).await?; let buckets: Vec> = jvm.load_array(&table, 0, table_len).await?; assert!(buckets.iter().all(ClassInstanceRef::is_null)); diff --git a/rustjava-runtime/tests/classes/java/util/test_hash_set.rs b/rustjava-runtime/tests/classes/java/util/test_hash_set.rs index ef82eaf3..2269b8ab 100644 --- a/rustjava-runtime/tests/classes/java/util/test_hash_set.rs +++ b/rustjava-runtime/tests/classes/java/util/test_hash_set.rs @@ -80,7 +80,7 @@ async fn test_hash_set_add_duplicate_contains_remove_null_and_clear() -> Result< assert!(jvm.is_instance(&*hash_set, "java/util/AbstractSet")); assert!(!jvm.is_instance(&*hash_set, "java/util/List")); - let present: ClassInstanceRef = jvm.get_field(&hash_set, "present", "Ljava/lang/Object;").await?; + let present: ClassInstanceRef = jvm.get_field(&hash_set, "java/util/HashSet", "present", "Ljava/lang/Object;").await?; assert!(!present.is_null()); let value = JavaLangString::from_rust_string(&jvm, "same").await?; @@ -321,8 +321,8 @@ async fn test_hash_set_zero_capacity_add_path() -> Result<()> { let jvm = test_jvm().await?; let hash_set = jvm.new_class("java/util/HashSet", "(I)V", (0,)).await?; - let map: ClassInstanceRef = jvm.get_field(&hash_set, "map", "Ljava/util/HashMap;").await?; - let table: ClassInstanceRef> = jvm.get_field(&map, "table", "[Ljava/util/HashMap$Entry;").await?; + let map: ClassInstanceRef = jvm.get_field(&hash_set, "java/util/HashSet", "map", "Ljava/util/HashMap;").await?; + let table: ClassInstanceRef> = jvm.get_field(&map, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; assert_eq!(jvm.array_length(&table).await?, 0); let value = JavaLangString::from_rust_string(&jvm, "zero-capacity").await?; @@ -353,7 +353,7 @@ async fn test_hash_set_zero_capacity_add_path() -> Result<()> { .await?; assert!(!added); - let table: ClassInstanceRef> = jvm.get_field(&map, "table", "[Ljava/util/HashMap$Entry;").await?; + let table: ClassInstanceRef> = jvm.get_field(&map, "java/util/HashMap", "table", "[Ljava/util/HashMap$Entry;").await?; assert!(jvm.array_length(&table).await? >= 1); let size: i32 = jvm diff --git a/rustjava-runtime/tests/classes/java/util/test_linked_hash_map.rs b/rustjava-runtime/tests/classes/java/util/test_linked_hash_map.rs index 3e6313e6..a48b5428 100644 --- a/rustjava-runtime/tests/classes/java/util/test_linked_hash_map.rs +++ b/rustjava-runtime/tests/classes/java/util/test_linked_hash_map.rs @@ -35,15 +35,15 @@ impl LimitedLinkedHashMap { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, limit: i32) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/util/LinkedHashMap", "", "()V", ()).await?; - jvm.put_field(&mut this, "limit", "I", limit).await?; - jvm.put_field(&mut this, "callbacks", "I", 0).await + jvm.put_field(&mut this, "LimitedLinkedHashMap", "limit", "I", limit).await?; + jvm.put_field(&mut this, "LimitedLinkedHashMap", "callbacks", "I", 0).await } async fn remove_eldest_entry(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, _: ClassInstanceRef) -> Result { - let callbacks: i32 = jvm.get_field(&this, "callbacks", "I").await?; - jvm.put_field(&mut this, "callbacks", "I", callbacks + 1).await?; + let callbacks: i32 = jvm.get_field(&this, "LimitedLinkedHashMap", "callbacks", "I").await?; + jvm.put_field(&mut this, "LimitedLinkedHashMap", "callbacks", "I", callbacks + 1).await?; let size: i32 = jvm.invoke_virtual(&this, "LimitedLinkedHashMap", "size", "()I", ()).await?; - let limit: i32 = jvm.get_field(&this, "limit", "I").await?; + let limit: i32 = jvm.get_field(&this, "LimitedLinkedHashMap", "limit", "I").await?; Ok(size > limit) } @@ -537,7 +537,7 @@ async fn linked_hash_map_copy_and_remove_eldest_entry_preserve_policy_and_order( view_strings(&jvm, &limited, "keySet", "()Ljava/util/Set;").await?, vec![Some("b".into()), Some("c".into())] ); - assert_eq!(jvm.get_field::(&limited, "callbacks", "I").await?, 3); + assert_eq!(jvm.get_field::(&limited, "LimitedLinkedHashMap", "callbacks", "I").await?, 3); let key = JavaLangString::from_rust_string(&jvm, "c").await?; let value = JavaLangString::from_rust_string(&jvm, "C").await?; @@ -550,7 +550,7 @@ async fn linked_hash_map_copy_and_remove_eldest_entry_preserve_policy_and_order( (key, value), ) .await?; - assert_eq!(jvm.get_field::(&limited, "callbacks", "I").await?, 3); + assert_eq!(jvm.get_field::(&limited, "LimitedLinkedHashMap", "callbacks", "I").await?, 3); let copy: ClassInstanceRef = jvm.new_class("java/util/LinkedHashMap", "(Ljava/util/Map;)V", (limited,)).await?.into(); assert_eq!( diff --git a/rustjava-runtime/tests/classes/java/util/test_list_views.rs b/rustjava-runtime/tests/classes/java/util/test_list_views.rs index a2832b53..2ec7a9bf 100644 --- a/rustjava-runtime/tests/classes/java/util/test_list_views.rs +++ b/rustjava-runtime/tests/classes/java/util/test_list_views.rs @@ -484,9 +484,15 @@ async fn linked_list_list_iterator_covers_boundaries_and_every_legal_transition( 0 ); - let header: ClassInstanceRef = jvm.get_field(&list, "header", "Ljava/util/LinkedList$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let previous: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&list, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let previous: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>(&header, &header.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (next,)) .await? @@ -526,11 +532,21 @@ async fn linked_list_sentinel_unlinks_middle_single_and_last_entries() -> Result assert_eq!(JavaLangString::to_rust_string(&jvm, &value).await?, expected); } - let header: ClassInstanceRef = jvm.get_field(&list, "header", "Ljava/util/LinkedList$Entry;").await?; - let first: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let last: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; - let first_next: ClassInstanceRef = jvm.get_field(&first, "next", "Ljava/util/LinkedList$Entry;").await?; - let last_previous: ClassInstanceRef = jvm.get_field(&last, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&list, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let first: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let last: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; + let first_next: ClassInstanceRef = jvm + .get_field(&first, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let last_previous: ClassInstanceRef = jvm + .get_field(&last, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>(&last, &last.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (first_next,)) .await? @@ -550,9 +566,15 @@ async fn linked_list_sentinel_unlinks_middle_single_and_last_entries() -> Result .invoke_virtual(&list, &list.class_definition().name(), "removeFirst", "()Ljava/lang/Object;", ()) .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &removed).await?, "first"); - let header: ClassInstanceRef = jvm.get_field(&list, "header", "Ljava/util/LinkedList$Entry;").await?; - let only_next: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let only_previous: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&list, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let only_next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let only_previous: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>( &only_next, @@ -568,8 +590,12 @@ async fn linked_list_sentinel_unlinks_middle_single_and_last_entries() -> Result .invoke_virtual(&list, &list.class_definition().name(), "removeLast", "()Ljava/lang/Object;", ()) .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &removed).await?, "last"); - let next: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let previous: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let previous: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>(&header, &header.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (next,)) .await? @@ -608,9 +634,15 @@ async fn list_02_to_04_linked_list_uses_sentinel_and_live_list_iterator() -> Res let jvm = test_jvm().await?; let list = jvm.new_class("java/util/LinkedList", "()V", ()).await?; - let header: ClassInstanceRef = jvm.get_field(&list, "header", "Ljava/util/LinkedList$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let previous: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&list, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let previous: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>(&header, &header.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (next,)) .await? @@ -711,9 +743,15 @@ async fn list_02_to_04_linked_list_uses_sentinel_and_live_list_iterator() -> Res assert_eq!(jvm.array_length(&array).await?, 4); let _: () = jvm.invoke_virtual(&list, &list.class_definition().name(), "clear", "()V", ()).await?; - let header: ClassInstanceRef = jvm.get_field(&list, "header", "Ljava/util/LinkedList$Entry;").await?; - let next: ClassInstanceRef = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?; - let previous: ClassInstanceRef = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?; + let header: ClassInstanceRef = jvm + .get_field(&list, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;") + .await?; + let next: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;") + .await?; + let previous: ClassInstanceRef = jvm + .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;") + .await?; assert!( jvm.invoke_virtual::<_, bool>(&header, &header.class_definition().name(), "equals", "(Ljava/lang/Object;)Z", (next,)) .await? diff --git a/rustjava-runtime/tests/classes/java/util/test_properties.rs b/rustjava-runtime/tests/classes/java/util/test_properties.rs index 97860608..d511461a 100644 --- a/rustjava-runtime/tests/classes/java/util/test_properties.rs +++ b/rustjava-runtime/tests/classes/java/util/test_properties.rs @@ -89,19 +89,19 @@ impl FailingAfterInputStream { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, data: ClassInstanceRef>) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/io/InputStream", "", "()V", ()).await?; - jvm.put_field(&mut this, "data", "[B", data).await?; - jvm.put_field(&mut this, "position", "I", 0).await + jvm.put_field(&mut this, "FailingAfterInputStream", "data", "[B", data).await?; + jvm.put_field(&mut this, "FailingAfterInputStream", "position", "I", 0).await } async fn read(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result { - let data: ClassInstanceRef> = jvm.get_field(&this, "data", "[B").await?; - let position: i32 = jvm.get_field(&this, "position", "I").await?; + let data: ClassInstanceRef> = jvm.get_field(&this, "FailingAfterInputStream", "data", "[B").await?; + let position: i32 = jvm.get_field(&this, "FailingAfterInputStream", "position", "I").await?; if position as usize >= jvm.array_length(&data).await? { return Err(jvm.exception("java/io/IOException", "read failed after data").await); } let value: i8 = jvm.load_array(&data, position as usize, 1).await?.into_iter().next().unwrap(); - jvm.put_field(&mut this, "position", "I", position + 1).await?; + jvm.put_field(&mut this, "FailingAfterInputStream", "position", "I", position + 1).await?; Ok(value as u8 as i32) } } @@ -214,14 +214,18 @@ async fn prop_01_constructors_and_defaults_field() -> Result<()> { let jvm = test_jvm().await?; let empty = jvm.new_class("java/util/Properties", "()V", ()).await?; - let defaults: ClassInstanceRef = jvm.get_field(&empty, "defaults", "Ljava/util/Properties;").await?; + let defaults: ClassInstanceRef = jvm + .get_field(&empty, "java/util/Properties", "defaults", "Ljava/util/Properties;") + .await?; assert!(defaults.is_null()); let parent = jvm.new_class("java/util/Properties", "()V", ()).await?; let child = jvm .new_class("java/util/Properties", "(Ljava/util/Properties;)V", (parent.clone(),)) .await?; - let actual: ClassInstanceRef = jvm.get_field(&child, "defaults", "Ljava/util/Properties;").await?; + let actual: ClassInstanceRef = jvm + .get_field(&child, "java/util/Properties", "defaults", "Ljava/util/Properties;") + .await?; let key = JavaLangString::from_rust_string(&jvm, "shared-instance").await?; let value = JavaLangString::from_rust_string(&jvm, "yes").await?; let _: ClassInstanceRef = jvm diff --git a/rustjava-runtime/tests/classes/java/util/test_random.rs b/rustjava-runtime/tests/classes/java/util/test_random.rs index cf29e434..82bb08b4 100644 --- a/rustjava-runtime/tests/classes/java/util/test_random.rs +++ b/rustjava-runtime/tests/classes/java/util/test_random.rs @@ -223,15 +223,15 @@ async fn rng_01_gaussian_matches_jdk_seed_oracle_and_consumes_cache() -> Result< .invoke_virtual(&random, &random.class_definition().name(), "nextGaussian", "()D", ()) .await?; assert!((first - 1.1419053154730547).abs() < 1e-15); - assert!(jvm.get_field::(&random, "haveNextNextGaussian", "Z").await?); - let cached: f64 = jvm.get_field(&random, "nextNextGaussian", "D").await?; + assert!(jvm.get_field::(&random, "java/util/Random", "haveNextNextGaussian", "Z").await?); + let cached: f64 = jvm.get_field(&random, "java/util/Random", "nextNextGaussian", "D").await?; let second: f64 = jvm .invoke_virtual(&random, &random.class_definition().name(), "nextGaussian", "()D", ()) .await?; assert_eq!(second.to_bits(), cached.to_bits()); assert!((second - 0.9194079489827879).abs() < 1e-15); - assert!(!jvm.get_field::(&random, "haveNextNextGaussian", "Z").await?); + assert!(!jvm.get_field::(&random, "java/util/Random", "haveNextNextGaussian", "Z").await?); let after_cached: i32 = jvm .invoke_virtual(&random, &random.class_definition().name(), "nextInt", "()I", ()) @@ -260,12 +260,12 @@ async fn rng_02_set_seed_clears_gaussian_cache() -> Result<()> { let first: f64 = jvm .invoke_virtual(&random, &random.class_definition().name(), "nextGaussian", "()D", ()) .await?; - assert!(jvm.get_field::(&random, "haveNextNextGaussian", "Z").await?); + assert!(jvm.get_field::(&random, "java/util/Random", "haveNextNextGaussian", "Z").await?); let _: () = jvm .invoke_virtual(&random, &random.class_definition().name(), "setSeed", "(J)V", (42i64,)) .await?; - assert!(!jvm.get_field::(&random, "haveNextNextGaussian", "Z").await?); + assert!(!jvm.get_field::(&random, "java/util/Random", "haveNextNextGaussian", "Z").await?); let reset_first: f64 = jvm .invoke_virtual(&random, &random.class_definition().name(), "nextGaussian", "()D", ()) .await?; diff --git a/rustjava-runtime/tests/classes/java/util/test_string_tokenizer.rs b/rustjava-runtime/tests/classes/java/util/test_string_tokenizer.rs index 58c03977..122b327c 100644 --- a/rustjava-runtime/tests/classes/java/util/test_string_tokenizer.rs +++ b/rustjava-runtime/tests/classes/java/util/test_string_tokenizer.rs @@ -61,7 +61,10 @@ async fn tok_01_constructors_and_utf16_delimiters() -> Result<()> { let jvm = test_jvm().await?; let input = JavaLangString::from_rust_string(&jvm, " one\t two\nthree ").await?; let tokenizer = jvm.new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input,)).await?; - assert_eq!(jvm.get_field::(&tokenizer, "maxPosition", "I").await?, 16); + assert_eq!( + jvm.get_field::(&tokenizer, "java/util/StringTokenizer", "maxPosition", "I").await?, + 16 + ); assert_eq!( jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ()) .await?, @@ -232,17 +235,17 @@ async fn tok_03_next_token_shares_input_value() -> Result<()> { .new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input.clone(),)) .await?; - let input_value: ClassInstanceRef> = jvm.get_field(&input, "value", "[C").await?; + let input_value: ClassInstanceRef> = jvm.get_field(&input, "java/lang/String", "value", "[C").await?; for (expected, offset) in [("one", 1), ("two", 5)] { let token: ClassInstanceRef = jvm .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ()) .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &token).await?, expected); - let token_value: ClassInstanceRef> = jvm.get_field(&token, "value", "[C").await?; + let token_value: ClassInstanceRef> = jvm.get_field(&token, "java/lang/String", "value", "[C").await?; assert_eq!(input_value.identity(), token_value.identity()); - assert_eq!(jvm.get_field::(&token, "offset", "I").await?, offset); - assert_eq!(jvm.get_field::(&token, "count", "I").await?, 3); + assert_eq!(jvm.get_field::(&token, "java/lang/String", "offset", "I").await?, offset); + assert_eq!(jvm.get_field::(&token, "java/lang/String", "count", "I").await?, 3); } Ok(()) @@ -257,12 +260,15 @@ async fn tok_04_substring_input_composes_offsets_and_shares_root_value() -> Resu .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &input).await?, "one two"); - let root_value: ClassInstanceRef> = jvm.get_field(&root, "value", "[C").await?; + let root_value: ClassInstanceRef> = jvm.get_field(&root, "java/lang/String", "value", "[C").await?; let tokenizer = jvm .new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input.clone(),)) .await?; - assert_eq!(jvm.get_field::(&tokenizer, "maxPosition", "I").await?, 7); + assert_eq!( + jvm.get_field::(&tokenizer, "java/util/StringTokenizer", "maxPosition", "I").await?, + 7 + ); assert_eq!( jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ()) .await?, @@ -274,10 +280,10 @@ async fn tok_04_substring_input_composes_offsets_and_shares_root_value() -> Resu .await?; assert_eq!(JavaLangString::to_rust_string(&jvm, &token).await?, expected); - let token_value: ClassInstanceRef> = jvm.get_field(&token, "value", "[C").await?; + let token_value: ClassInstanceRef> = jvm.get_field(&token, "java/lang/String", "value", "[C").await?; assert_eq!(root_value.identity(), token_value.identity()); - assert_eq!(jvm.get_field::(&token, "offset", "I").await?, offset); - assert_eq!(jvm.get_field::(&token, "count", "I").await?, 3); + assert_eq!(jvm.get_field::(&token, "java/lang/String", "offset", "I").await?, offset); + assert_eq!(jvm.get_field::(&token, "java/lang/String", "count", "I").await?, 3); } assert!( !jvm.invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreTokens", "()Z", ()) diff --git a/rustjava-runtime/tests/classes/java/util/test_timer.rs b/rustjava-runtime/tests/classes/java/util/test_timer.rs index 48a13b17..cade7856 100644 --- a/rustjava-runtime/tests/classes/java/util/test_timer.rs +++ b/rustjava-runtime/tests/classes/java/util/test_timer.rs @@ -46,23 +46,25 @@ impl TestTimerTask { async fn run(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result<()> { jvm.monitor_enter(&this).await?; let update_result = async { - let run_count: i32 = jvm.get_field(&this, "runCount", "I").await?; + let run_count: i32 = jvm.get_field(&this, "TestTimerTask", "runCount", "I").await?; let scheduled_time: i64 = jvm.invoke_virtual(&this, "TestTimerTask", "scheduledExecutionTime", "()J", ()).await?; let actual_time = context.now() as i64; if run_count == 0 { - jvm.put_field(&mut this, "firstScheduledTime", "J", scheduled_time).await?; - jvm.put_field(&mut this, "firstActualTime", "J", actual_time).await?; + jvm.put_field(&mut this, "TestTimerTask", "firstScheduledTime", "J", scheduled_time) + .await?; + jvm.put_field(&mut this, "TestTimerTask", "firstActualTime", "J", actual_time).await?; } - jvm.put_field(&mut this, "lastScheduledTime", "J", scheduled_time).await?; - jvm.put_field(&mut this, "lastActualTime", "J", actual_time).await?; - jvm.put_field(&mut this, "runCount", "I", run_count + 1).await?; + jvm.put_field(&mut this, "TestTimerTask", "lastScheduledTime", "J", scheduled_time) + .await?; + jvm.put_field(&mut this, "TestTimerTask", "lastActualTime", "J", actual_time).await?; + jvm.put_field(&mut this, "TestTimerTask", "runCount", "I", run_count + 1).await?; jvm.object_notify(&this, usize::MAX).await } .await; let exit_result = jvm.monitor_exit(&this).await; update_result.and(exit_result)?; - if jvm.get_field::(&this, "throwOnRun", "Z").await? { + if jvm.get_field::(&this, "TestTimerTask", "throwOnRun", "Z").await? { return Err(jvm.exception("java/lang/RuntimeException", "timer task failed").await); } Ok(()) @@ -225,9 +227,9 @@ async fn timer_01_to_05_registers_jdk_shaped_api_and_state() -> Result<()> { let (runtime, jvm) = timer_test_jvm(1_000).await?; let instance: ClassInstanceRef = jvm.new_class("TestTimerTask", "()V", ()).await?.into(); - assert_eq!(jvm.get_field::(&instance, "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&instance, "TestTimerTask", "state", "I").await?, 0); assert!(!jvm.invoke_virtual::<_, bool>(&instance, "TestTimerTask", "cancel", "()Z", ()).await?); - assert_eq!(jvm.get_field::(&instance, "state", "I").await?, 3); + assert_eq!(jvm.get_field::(&instance, "TestTimerTask", "state", "I").await?, 3); assert_eq!( jvm.invoke_virtual::<_, i64>(&instance, "TestTimerTask", "scheduledExecutionTime", "()J", ()) .await?, @@ -337,9 +339,9 @@ async fn timer_validation_happens_before_task_mutation() -> Result<()> { "java/lang/NullPointerException", ) .await; - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 0); - assert_eq!(jvm.get_field::(&task, "nextExecutionTime", "J").await?, 0); - assert_eq!(jvm.get_field::(&task, "period", "J").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "nextExecutionTime", "J").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "period", "J").await?, 0); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; assert_exception( @@ -354,7 +356,7 @@ async fn timer_validation_happens_before_task_mutation() -> Result<()> { "java/lang/IllegalStateException", ) .await; - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 0); await_spawn(next_spawn(&runtime).await, "validation timer worker").await?; Ok(()) } @@ -383,8 +385,11 @@ async fn timer_normalizes_long_max_period_and_rejects_first_recurrence_overflow( (fixed_rate.clone(), 0i64, i64::MAX), ) .await?; - assert_eq!(jvm.get_field::(&fixed_delay, "period", "J").await?, (-i64::MAX) >> 1); - assert_eq!(jvm.get_field::(&fixed_rate, "period", "J").await?, i64::MAX >> 1); + assert_eq!( + jvm.get_field::(&fixed_delay, "TestTimerTask", "period", "J").await?, + (-i64::MAX) >> 1 + ); + assert_eq!(jvm.get_field::(&fixed_rate, "TestTimerTask", "period", "J").await?, i64::MAX >> 1); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(next_spawn(&runtime).await, "large-period timer worker").await?; @@ -404,8 +409,8 @@ async fn timer_normalizes_long_max_period_and_rejects_first_recurrence_overflow( "java/lang/IllegalArgumentException", ) .await; - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 0); - assert_eq!(jvm.get_field::(&task, "period", "J").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "period", "J").await?, 0); } let date = jvm.new_class("java/util/Date", "(J)V", (i64::MAX - 50,)).await?; let dated: ClassInstanceRef = jvm.new_class("TestTimerTask", "()V", ()).await?.into(); @@ -421,7 +426,7 @@ async fn timer_normalizes_long_max_period_and_rejects_first_recurrence_overflow( "java/lang/IllegalArgumentException", ) .await; - assert_eq!(jvm.get_field::(&dated, "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&dated, "TestTimerTask", "state", "I").await?, 0); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(next_spawn(&runtime).await, "near-boundary validation timer worker").await?; Ok(()) @@ -445,8 +450,11 @@ async fn timer_worker_stops_periodic_tasks_when_next_deadline_overflows() -> Res let first_notification = prepare_task_notification(&jvm, &fixed_rate).await?; let mut worker = next_spawn(&runtime).await; wait_for_task_notification(&jvm, &fixed_rate, first_notification).await?; - assert_eq!(jvm.get_field::(&fixed_rate, "runCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&fixed_rate, "nextExecutionTime", "J").await?, i64::MAX - 40); + assert_eq!(jvm.get_field::(&fixed_rate, "TestTimerTask", "runCount", "I").await?, 1); + assert_eq!( + jvm.get_field::(&fixed_rate, "TestTimerTask", "nextExecutionTime", "J").await?, + i64::MAX - 40 + ); let timeout = next_spawn_while_worker_runs(&runtime, &mut worker).await; assert_eq!( @@ -459,11 +467,15 @@ async fn timer_worker_stops_periodic_tasks_when_next_deadline_overflows() -> Res runtime.advance_time(Duration::from_millis(60)); await_spawn(timeout, "near-boundary fixed-rate timeout callback").await?; wait_for_task_notification(&jvm, &fixed_rate, second_notification).await?; - assert_eq!(jvm.get_field::(&fixed_rate, "runCount", "I").await?, 2); - assert_eq!(jvm.get_field::(&fixed_rate, "state", "I").await?, 2); - let thread: ClassInstanceRef = jvm.get_field(&timer, "thread", "Ljava/util/Timer$TimerThread;").await?; - let queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; - assert_eq!(jvm.get_field::(&queue, "size", "I").await?, 0); + assert_eq!(jvm.get_field::(&fixed_rate, "TestTimerTask", "runCount", "I").await?, 2); + assert_eq!(jvm.get_field::(&fixed_rate, "TestTimerTask", "state", "I").await?, 2); + let thread: ClassInstanceRef = jvm + .get_field(&timer, "java/util/Timer", "thread", "Ljava/util/Timer$TimerThread;") + .await?; + let queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; + assert_eq!(jvm.get_field::(&queue, "java/util/Timer$TaskQueue", "size", "I").await?, 0); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(worker, "near-boundary fixed-rate timer worker").await?; @@ -483,8 +495,8 @@ async fn timer_worker_stops_periodic_tasks_when_next_deadline_overflows() -> Res let notification = prepare_task_notification(&jvm, &fixed_delay).await?; let worker = next_spawn(&runtime).await; wait_for_task_notification(&jvm, &fixed_delay, notification).await?; - assert_eq!(jvm.get_field::(&fixed_delay, "runCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&fixed_delay, "state", "I").await?, 2); + assert_eq!(jvm.get_field::(&fixed_delay, "TestTimerTask", "runCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&fixed_delay, "TestTimerTask", "state", "I").await?, 2); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(worker, "near-boundary fixed-delay timer worker").await?; Ok(()) @@ -515,10 +527,16 @@ async fn timer_uses_min_heap_and_rejects_task_reuse() -> Result<()> { ) .await?; - let thread: ClassInstanceRef = jvm.get_field(&timer, "thread", "Ljava/util/Timer$TimerThread;").await?; - let queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; - assert_eq!(jvm.get_field::(&queue, "size", "I").await?, 2); - let heap: ClassInstanceRef> = jvm.get_field(&queue, "queue", "[Ljava/util/TimerTask;").await?; + let thread: ClassInstanceRef = jvm + .get_field(&timer, "java/util/Timer", "thread", "Ljava/util/Timer$TimerThread;") + .await?; + let queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; + assert_eq!(jvm.get_field::(&queue, "java/util/Timer$TaskQueue", "size", "I").await?, 2); + let heap: ClassInstanceRef> = jvm + .get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;") + .await?; let first: ClassInstanceRef = jvm.load_array(&heap, 1, 1).await?.remove(0); assert_eq!(first.identity(), earlier.identity()); @@ -535,7 +553,7 @@ async fn timer_uses_min_heap_and_rejects_task_reuse() -> Result<()> { ) .await; let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; - assert_eq!(jvm.get_field::(&queue, "size", "I").await?, 0); + assert_eq!(jvm.get_field::(&queue, "java/util/Timer$TaskQueue", "size", "I").await?, 0); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(next_spawn(&runtime).await, "heap timer worker").await?; Ok(()) @@ -569,17 +587,17 @@ async fn timer_one_shot_executes_once_and_records_scheduled_time() -> Result<()> await_spawn(timeout, "one-shot timeout callback").await?; wait_for_task_notification(&jvm, &task, notification).await?; - assert_eq!(jvm.get_field::(&task, "runCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 2); - assert_eq!(jvm.get_field::(&task, "firstScheduledTime", "J").await?, 1_100); - assert_eq!(jvm.get_field::(&task, "firstActualTime", "J").await?, 1_100); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "runCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 2); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "firstScheduledTime", "J").await?, 1_100); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "firstActualTime", "J").await?, 1_100); assert_eq!( jvm.invoke_virtual::<_, i64>(&task, "TestTimerTask", "scheduledExecutionTime", "()J", ()) .await?, 1_100 ); assert!(!jvm.invoke_virtual::<_, bool>(&task, "TestTimerTask", "cancel", "()Z", ()).await?); - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 3); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 3); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(worker, "one-shot timer worker").await?; @@ -628,8 +646,8 @@ async fn timer_new_first_task_wakes_worker_and_recomputes_deadline() -> Result<( runtime.advance_time(Duration::from_millis(100)); await_spawn(new_timeout, "earlier timeout callback").await?; wait_for_task_notification(&jvm, &earlier, notification).await?; - assert_eq!(jvm.get_field::(&earlier, "runCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&later, "runCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&earlier, "TestTimerTask", "runCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&later, "TestTimerTask", "runCount", "I").await?, 0); let stale_later_timeout = tokio::time::timeout(TEST_BARRIER_TIMEOUT, runtime.next_spawn_callback()) .await @@ -659,12 +677,12 @@ async fn timer_task_cancel_only_reports_a_live_schedule() -> Result<()> { .await?; assert!(jvm.invoke_virtual::<_, bool>(&task, "TestTimerTask", "cancel", "()Z", ()).await?); assert!(!jvm.invoke_virtual::<_, bool>(&task, "TestTimerTask", "cancel", "()Z", ()).await?); - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 3); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 3); let worker = next_spawn(&runtime).await; let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; await_spawn(worker, "cancelled-task timer worker").await?; - assert_eq!(jvm.get_field::(&task, "runCount", "I").await?, 0); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "runCount", "I").await?, 0); assert_eq!( jvm.invoke_virtual::<_, i64>(&task, "TestTimerTask", "scheduledExecutionTime", "()J", ()) .await?, @@ -687,7 +705,7 @@ async fn timer_fixed_delay_uses_actual_execution_time() -> Result<()> { (task.clone(), 100i64, 50i64), ) .await?; - assert_eq!(jvm.get_field::(&task, "period", "J").await?, -50); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "period", "J").await?, -50); let notification = prepare_task_notification(&jvm, &task).await?; let mut worker = next_spawn(&runtime).await; @@ -710,11 +728,11 @@ async fn timer_fixed_delay_uses_actual_execution_time() -> Result<()> { .await .expect("timed out waiting for fixed-delay reschedule"); - assert_eq!(jvm.get_field::(&task, "runCount", "I").await?, 1); - assert_eq!(jvm.get_field::(&task, "state", "I").await?, 1); - assert_eq!(jvm.get_field::(&task, "firstScheduledTime", "J").await?, 1_100); - assert_eq!(jvm.get_field::(&task, "firstActualTime", "J").await?, 1_200); - assert_eq!(jvm.get_field::(&task, "nextExecutionTime", "J").await?, 1_250); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "runCount", "I").await?, 1); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "state", "I").await?, 1); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "firstScheduledTime", "J").await?, 1_100); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "firstActualTime", "J").await?, 1_200); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "nextExecutionTime", "J").await?, 1_250); drop(next_timeout); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; @@ -736,7 +754,7 @@ async fn timer_fixed_rate_catches_up_from_previous_deadline() -> Result<()> { (task.clone(), 100i64, 50i64), ) .await?; - assert_eq!(jvm.get_field::(&task, "period", "J").await?, 50); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "period", "J").await?, 50); let notification = prepare_task_notification(&jvm, &task).await?; let mut worker = next_spawn(&runtime).await; @@ -759,10 +777,10 @@ async fn timer_fixed_rate_catches_up_from_previous_deadline() -> Result<()> { .await .expect("timed out waiting for fixed-rate reschedule"); - assert_eq!(jvm.get_field::(&task, "runCount", "I").await?, 3); - assert_eq!(jvm.get_field::(&task, "firstScheduledTime", "J").await?, 1_100); - assert_eq!(jvm.get_field::(&task, "lastScheduledTime", "J").await?, 1_200); - assert_eq!(jvm.get_field::(&task, "nextExecutionTime", "J").await?, 1_250); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "runCount", "I").await?, 3); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "firstScheduledTime", "J").await?, 1_100); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "lastScheduledTime", "J").await?, 1_200); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "nextExecutionTime", "J").await?, 1_250); drop(next_timeout); let _: () = jvm.invoke_virtual(&timer, &timer.class_definition().name(), "cancel", "()V", ()).await?; @@ -785,20 +803,27 @@ async fn timer_date_schedule_and_task_exception_close_worker() -> Result<()> { (task.clone(), date, 25i64), ) .await?; - assert_eq!(jvm.get_field::(&task, "nextExecutionTime", "J").await?, 1_000); - assert_eq!(jvm.get_field::(&task, "period", "J").await?, -25); - jvm.put_field(&mut task, "throwOnRun", "Z", true).await?; + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "nextExecutionTime", "J").await?, 1_000); + assert_eq!(jvm.get_field::(&task, "TestTimerTask", "period", "J").await?, -25); + jvm.put_field(&mut task, "TestTimerTask", "throwOnRun", "Z", true).await?; let notification = prepare_task_notification(&jvm, &task).await?; let worker = next_spawn(&runtime).await; wait_for_task_notification(&jvm, &task, notification).await?; await_spawn(worker, "exception timer worker").await?; - let thread: ClassInstanceRef = jvm.get_field(&timer, "thread", "Ljava/util/Timer$TimerThread;").await?; - let queue: ClassInstanceRef = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?; - assert!(!jvm.get_field::(&thread, "newTasksMayBeScheduled", "Z").await?); - assert!(!jvm.get_field::(&thread, "alive", "Z").await?); - assert_eq!(jvm.get_field::(&queue, "size", "I").await?, 0); + let thread: ClassInstanceRef = jvm + .get_field(&timer, "java/util/Timer", "thread", "Ljava/util/Timer$TimerThread;") + .await?; + let queue: ClassInstanceRef = jvm + .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;") + .await?; + assert!( + !jvm.get_field::(&thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z") + .await? + ); + assert!(!jvm.get_field::(&thread, "java/util/Timer$TimerThread", "alive", "Z").await?); + assert_eq!(jvm.get_field::(&queue, "java/util/Timer$TaskQueue", "size", "I").await?, 0); let fresh: ClassInstanceRef = jvm.new_class("TestTimerTask", "()V", ()).await?.into(); assert_exception( @@ -813,6 +838,6 @@ async fn timer_date_schedule_and_task_exception_close_worker() -> Result<()> { "java/lang/IllegalStateException", ) .await; - assert_eq!(jvm.get_field::(&fresh, "state", "I").await?, 0); + assert_eq!(jvm.get_field::(&fresh, "TestTimerTask", "state", "I").await?, 0); Ok(()) } diff --git a/rustjava-runtime/tests/classes/java/util/test_tree_map.rs b/rustjava-runtime/tests/classes/java/util/test_tree_map.rs index cc1593b8..1b6bf43e 100644 --- a/rustjava-runtime/tests/classes/java/util/test_tree_map.rs +++ b/rustjava-runtime/tests/classes/java/util/test_tree_map.rs @@ -52,9 +52,9 @@ impl TreeTestComparator { absolute: bool, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "reverse", "Z", reverse).await?; - jvm.put_field(&mut this, "allowNull", "Z", allow_null).await?; - jvm.put_field(&mut this, "absolute", "Z", absolute).await + jvm.put_field(&mut this, "TreeTestComparator", "reverse", "Z", reverse).await?; + jvm.put_field(&mut this, "TreeTestComparator", "allowNull", "Z", allow_null).await?; + jvm.put_field(&mut this, "TreeTestComparator", "absolute", "Z", absolute).await } async fn compare( @@ -64,7 +64,7 @@ impl TreeTestComparator { left: ClassInstanceRef, right: ClassInstanceRef, ) -> Result { - let allow_null: bool = jvm.get_field(&this, "allowNull", "Z").await?; + let allow_null: bool = jvm.get_field(&this, "TreeTestComparator", "allowNull", "Z").await?; let mut comparison = if left.is_null() || right.is_null() { if !allow_null { return Err(jvm.exception("java/lang/NullPointerException", "null key").await); @@ -83,13 +83,13 @@ impl TreeTestComparator { let mut right_value: i32 = jvm .invoke_virtual(&right, &right.class_definition().name(), "intValue", "()I", ()) .await?; - if jvm.get_field::(&this, "absolute", "Z").await? { + if jvm.get_field::(&this, "TreeTestComparator", "absolute", "Z").await? { left_value = left_value.saturating_abs(); right_value = right_value.saturating_abs(); } left_value.cmp(&right_value) as i32 }; - if jvm.get_field::(&this, "reverse", "Z").await? { + if jvm.get_field::(&this, "TreeTestComparator", "reverse", "Z").await? { comparison = -comparison; } Ok(comparison) @@ -118,21 +118,21 @@ impl TreeDirectionalKey { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, value: i32, fail: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "value", "I", value).await?; - jvm.put_field(&mut this, "fail", "Z", fail).await + jvm.put_field(&mut this, "TreeDirectionalKey", "value", "I", value).await?; + jvm.put_field(&mut this, "TreeDirectionalKey", "fail", "Z", fail).await } async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { - if jvm.get_field::(&this, "fail", "Z").await? { + if jvm.get_field::(&this, "TreeDirectionalKey", "fail", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "stored key comparison").await); } if other.is_null() || !jvm.is_instance(other.as_ref(), "TreeDirectionalKey") { return Err(jvm.exception("java/lang/ClassCastException", "TreeDirectionalKey required").await); } Ok(jvm - .get_field::(&this, "value", "I") + .get_field::(&this, "TreeDirectionalKey", "value", "I") .await? - .cmp(&jvm.get_field::(&other, "value", "I").await?) as i32) + .cmp(&jvm.get_field::(&other, "TreeDirectionalKey", "value", "I").await?) as i32) } } @@ -159,22 +159,21 @@ impl TreeEqualsValue { async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef, group: i32, answer: bool) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "group", "I", group).await?; - jvm.put_field(&mut this, "answer", "Z", answer).await + jvm.put_field(&mut this, "TreeEqualsValue", "group", "I", group).await?; + jvm.put_field(&mut this, "TreeEqualsValue", "answer", "Z", answer).await } async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef, other: ClassInstanceRef) -> Result { if other.is_null() || !jvm.is_instance(other.as_ref(), "TreeEqualsValue") { return Ok(false); } - Ok( - jvm.get_field::(&this, "group", "I").await? == jvm.get_field::(&other, "group", "I").await? - && jvm.get_field::(&this, "answer", "Z").await?, - ) + Ok(jvm.get_field::(&this, "TreeEqualsValue", "group", "I").await? + == jvm.get_field::(&other, "TreeEqualsValue", "group", "I").await? + && jvm.get_field::(&this, "TreeEqualsValue", "answer", "Z").await?) } async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result { - jvm.get_field(&this, "group", "I").await + jvm.get_field(&this, "TreeEqualsValue", "group", "I").await } } @@ -223,23 +222,25 @@ impl TreeChangingEntry { value: ClassInstanceRef, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "firstKey", "Ljava/lang/Object;", first_key).await?; - jvm.put_field(&mut this, "secondKey", "Ljava/lang/Object;", second_key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await + jvm.put_field(&mut this, "TreeChangingEntry", "firstKey", "Ljava/lang/Object;", first_key) + .await?; + jvm.put_field(&mut this, "TreeChangingEntry", "secondKey", "Ljava/lang/Object;", second_key) + .await?; + jvm.put_field(&mut this, "TreeChangingEntry", "value", "Ljava/lang/Object;", value).await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "keyCalls", "I").await?; - jvm.put_field(&mut this, "keyCalls", "I", calls + 1).await?; + let calls: i32 = jvm.get_field(&this, "TreeChangingEntry", "keyCalls", "I").await?; + jvm.put_field(&mut this, "TreeChangingEntry", "keyCalls", "I", calls + 1).await?; if calls == 0 { - jvm.get_field(&this, "firstKey", "Ljava/lang/Object;").await + jvm.get_field(&this, "TreeChangingEntry", "firstKey", "Ljava/lang/Object;").await } else { - jvm.get_field(&this, "secondKey", "Ljava/lang/Object;").await + jvm.get_field(&this, "TreeChangingEntry", "secondKey", "Ljava/lang/Object;").await } } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "TreeChangingEntry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -248,8 +249,9 @@ impl TreeChangingEntry { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let old = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old = jvm.get_field(&this, "TreeChangingEntry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "TreeChangingEntry", "value", "Ljava/lang/Object;", value) + .await?; Ok(old) } @@ -307,22 +309,23 @@ impl TreeValueProbeEntry { throw_value: bool, ) -> Result<()> { let _: () = jvm.invoke_special(&this, "java/lang/Object", "", "()V", ()).await?; - jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; - jvm.put_field(&mut this, "throwValue", "Z", throw_value).await + jvm.put_field(&mut this, "TreeValueProbeEntry", "key", "Ljava/lang/Object;", key).await?; + jvm.put_field(&mut this, "TreeValueProbeEntry", "value", "Ljava/lang/Object;", value) + .await?; + jvm.put_field(&mut this, "TreeValueProbeEntry", "throwValue", "Z", throw_value).await } async fn get_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef) -> Result> { - jvm.get_field(&this, "key", "Ljava/lang/Object;").await + jvm.get_field(&this, "TreeValueProbeEntry", "key", "Ljava/lang/Object;").await } async fn get_value(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef) -> Result> { - let calls: i32 = jvm.get_field(&this, "valueCalls", "I").await?; - jvm.put_field(&mut this, "valueCalls", "I", calls + 1).await?; - if jvm.get_field::(&this, "throwValue", "Z").await? { + let calls: i32 = jvm.get_field(&this, "TreeValueProbeEntry", "valueCalls", "I").await?; + jvm.put_field(&mut this, "TreeValueProbeEntry", "valueCalls", "I", calls + 1).await?; + if jvm.get_field::(&this, "TreeValueProbeEntry", "throwValue", "Z").await? { return Err(jvm.exception("java/lang/IllegalStateException", "getValue called").await); } - jvm.get_field(&this, "value", "Ljava/lang/Object;").await + jvm.get_field(&this, "TreeValueProbeEntry", "value", "Ljava/lang/Object;").await } async fn set_value( @@ -331,8 +334,9 @@ impl TreeValueProbeEntry { mut this: ClassInstanceRef, value: ClassInstanceRef, ) -> Result> { - let old = jvm.get_field(&this, "value", "Ljava/lang/Object;").await?; - jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?; + let old = jvm.get_field(&this, "TreeValueProbeEntry", "value", "Ljava/lang/Object;").await?; + jvm.put_field(&mut this, "TreeValueProbeEntry", "value", "Ljava/lang/Object;", value) + .await?; Ok(old) } @@ -441,14 +445,19 @@ async fn ordered_integer_keys(jvm: &Jvm, map: &ClassInstanceRef) -> Resu } async fn assert_red_black_invariants(jvm: &Jvm, map: &ClassInstanceRef) -> Result<()> { - let root: ClassInstanceRef = jvm.get_field(map, "root", "Ljava/util/TreeMap$Entry;").await?; + let root: ClassInstanceRef = jvm.get_field(map, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?; let expected_size: i32 = jvm.invoke_virtual(map, &map.class_definition().name(), "size", "()I", ()).await?; if root.is_null() { assert_eq!(expected_size, 0); return Ok(()); } - assert!(jvm.get_field::(&root, "color", "Z").await?, "root must be black"); - let root_parent: ClassInstanceRef = jvm.get_field(&root, "parent", "Ljava/util/TreeMap$Entry;").await?; + assert!( + jvm.get_field::(&root, "java/util/TreeMap$Entry", "color", "Z").await?, + "root must be black" + ); + let root_parent: ClassInstanceRef = jvm + .get_field(&root, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; assert!(root_parent.is_null()); let mut seen = BTreeSet::new(); @@ -456,20 +465,30 @@ async fn assert_red_black_invariants(jvm: &Jvm, map: &ClassInstanceRef) let mut stack = vec![(root, None::, None::, 0i32)]; while let Some((node, lower, upper, black_count)) = stack.pop() { assert!(seen.insert(node.identity()), "tree must not contain a cycle"); - let key: ClassInstanceRef = jvm.get_field(&node, "key", "Ljava/lang/Object;").await?; + let key: ClassInstanceRef = jvm.get_field(&node, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?; let key: i32 = jvm.invoke_virtual(&key, &key.class_definition().name(), "intValue", "()I", ()).await?; assert!(lower.is_none_or(|lower| key > lower)); assert!(upper.is_none_or(|upper| key < upper)); - let black = jvm.get_field::(&node, "color", "Z").await?; + let black = jvm.get_field::(&node, "java/util/TreeMap$Entry", "color", "Z").await?; let next_black_count = black_count + i32::from(black); - let left: ClassInstanceRef = jvm.get_field(&node, "left", "Ljava/util/TreeMap$Entry;").await?; - let right: ClassInstanceRef = jvm.get_field(&node, "right", "Ljava/util/TreeMap$Entry;").await?; + let left: ClassInstanceRef = jvm + .get_field(&node, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;") + .await?; + let right: ClassInstanceRef = jvm + .get_field(&node, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;") + .await?; if !black { if !left.is_null() { - assert!(jvm.get_field::(&left, "color", "Z").await?, "red node has red left child"); + assert!( + jvm.get_field::(&left, "java/util/TreeMap$Entry", "color", "Z").await?, + "red node has red left child" + ); } if !right.is_null() { - assert!(jvm.get_field::(&right, "color", "Z").await?, "red node has red right child"); + assert!( + jvm.get_field::(&right, "java/util/TreeMap$Entry", "color", "Z").await?, + "red node has red right child" + ); } } for (child, child_lower, child_upper) in [(left, lower, Some(key)), (right, Some(key), upper)] { @@ -477,7 +496,9 @@ async fn assert_red_black_invariants(jvm: &Jvm, map: &ClassInstanceRef) let leaf_height = next_black_count + 1; assert_eq!(*black_height.get_or_insert(leaf_height), leaf_height); } else { - let parent: ClassInstanceRef = jvm.get_field(&child, "parent", "Ljava/util/TreeMap$Entry;").await?; + let parent: ClassInstanceRef = jvm + .get_field(&child, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;") + .await?; assert!(!parent.is_null() && parent.identity() == node.identity()); stack.push((child, child_lower, child_upper, next_black_count)); } @@ -910,7 +931,7 @@ async fn tm_02_tm_03_natural_and_custom_comparator_contracts() -> Result<()> { ) .await?; let mut stored_for_mutation = stored_for_mutation; - jvm.put_field(&mut stored_for_mutation, "fail", "Z", true).await?; + jvm.put_field(&mut stored_for_mutation, "TreeDirectionalKey", "fail", "Z", true).await?; let query: ClassInstanceRef = jvm.new_class("TreeDirectionalKey", "(IZ)V", (7, false)).await?.into(); let found: ClassInstanceRef = jvm .invoke_virtual( @@ -2127,7 +2148,7 @@ async fn tm_03_views_use_jdk_value_equals_directions() -> Result<()> { ) .await? ); - assert_eq!(jvm.get_field::(&changing_entry, "keyCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&changing_entry, "TreeChangingEntry", "keyCalls", "I").await?, 1); assert!( !jvm.invoke_virtual::<_, bool>( &changing_map, @@ -2573,7 +2594,7 @@ async fn tm_03_entry_equals_short_circuits_before_reading_value() -> Result<()> .await? ); assert_eq!( - jvm.get_field::(&different_key, "valueCalls", "I").await?, + jvm.get_field::(&different_key, "TreeValueProbeEntry", "valueCalls", "I").await?, 0, "TreeMap.Entry.equals must not call getValue after a key mismatch" ); @@ -2599,7 +2620,7 @@ async fn tm_03_entry_equals_short_circuits_before_reading_value() -> Result<()> panic!("TreeMap.Entry.equals must call getValue after an equal key and propagate its exception"); }; assert!(jvm.is_instance(exception.as_ref(), "java/lang/IllegalStateException")); - assert_eq!(jvm.get_field::(&equal_key, "valueCalls", "I").await?, 1); + assert_eq!(jvm.get_field::(&equal_key, "TreeValueProbeEntry", "valueCalls", "I").await?, 1); Ok(()) } diff --git a/rustjava-runtime/tests/classes/org/rustjava/lang/test_rust_jar_class_loader.rs b/rustjava-runtime/tests/classes/org/rustjava/lang/test_rust_jar_class_loader.rs index 4263c9cb..87010de7 100644 --- a/rustjava-runtime/tests/classes/org/rustjava/lang/test_rust_jar_class_loader.rs +++ b/rustjava-runtime/tests/classes/org/rustjava/lang/test_rust_jar_class_loader.rs @@ -36,7 +36,7 @@ async fn test_find_class_uses_rustjar_runtime_source() -> Result<()> { .await?; assert!(!class.is_null()); - let defining_loader: ClassInstanceRef = jvm.get_field(&class, "classLoader", "Ljava/lang/ClassLoader;").await?; + let defining_loader: ClassInstanceRef = jvm.get_field(&class, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;").await?; assert!(jvm.is_instance(&**defining_loader, "org/rustjava/lang/RustJarClassLoader")); Ok(())