Rename structs

Author: komyg

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_abstract_operations/promise_all_record.rs

@@ -20,17 +20,17 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Copy)]
-pub struct PromiseAllRecordHeapData<'a> {
+pub struct PromiseAllRecord<'a> {
     pub remaining_unresolved_promise_count: u32,
     pub result_array: Array<'a>,
     pub promise: Promise<'a>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(transparent)]
-pub struct PromiseAllRecord<'a>(pub(crate) BaseIndex<'a, PromiseAllRecordHeapData<'a>>);
+pub struct PromiseAll<'a>(pub(crate) BaseIndex<'a, PromiseAllRecord<'a>>);
 
-impl<'a> PromiseAllRecordHeapData<'a> {
+impl<'a> PromiseAllRecord<'a> {
     pub(crate) fn on_promise_fufilled(
         &mut self,
         agent: &mut Agent,
@@ -51,47 +51,47 @@ impl<'a> PromiseAllRecordHeapData<'a> {
     }
 }
 
-impl PromiseAllRecord<'_> {
+impl PromiseAll<'_> {
     pub(crate) const fn get_index(self) -> usize {
         self.0.into_index()
     }
 }
 
-impl Index<PromiseAllRecord<'_>> for Agent {
-    type Output = PromiseAllRecordHeapData<'static>;
+impl Index<PromiseAll<'_>> for Agent {
+    type Output = PromiseAllRecord<'static>;
 
-    fn index(&self, index: PromiseAllRecord) -> &Self::Output {
+    fn index(&self, index: PromiseAll) -> &Self::Output {
         &self.heap.promise_all_records[index]
     }
 }
 
-impl IndexMut<PromiseAllRecord<'_>> for Agent {
-    fn index_mut(&mut self, index: PromiseAllRecord) -> &mut Self::Output {
+impl IndexMut<PromiseAll<'_>> for Agent {
+    fn index_mut(&mut self, index: PromiseAll) -> &mut Self::Output {
         &mut self.heap.promise_all_records[index]
     }
 }
 
-impl Index<PromiseAllRecord<'_>> for Vec<Option<PromiseAllRecordHeapData<'static>>> {
-    type Output = PromiseAllRecordHeapData<'static>;
+impl Index<PromiseAll<'_>> for Vec<Option<PromiseAllRecord<'static>>> {
+    type Output = PromiseAllRecord<'static>;
 
-    fn index(&self, index: PromiseAllRecord) -> &Self::Output {
+    fn index(&self, index: PromiseAll) -> &Self::Output {
         self.get(index.get_index())
             .expect("PromiseAllRecord out of bounds")
             .as_ref()
             .expect("PromiseAllRecord slot empty")
     }
 }
 
-impl IndexMut<PromiseAllRecord<'_>> for Vec<Option<PromiseAllRecordHeapData<'static>>> {
-    fn index_mut(&mut self, index: PromiseAllRecord) -> &mut Self::Output {
+impl IndexMut<PromiseAll<'_>> for Vec<Option<PromiseAllRecord<'static>>> {
+    fn index_mut(&mut self, index: PromiseAll) -> &mut Self::Output {
         self.get_mut(index.get_index())
             .expect("PromiseAllRecord out of bounds")
             .as_mut()
             .expect("PromiseAllRecord slot empty")
     }
 }
 
-impl HeapMarkAndSweep for PromiseAllRecordHeapData<'static> {
+impl HeapMarkAndSweep for PromiseAllRecord<'static> {
     fn mark_values(&self, queues: &mut WorkQueues) {
         self.result_array.mark_values(queues);
     }
@@ -101,8 +101,8 @@ impl HeapMarkAndSweep for PromiseAllRecordHeapData<'static> {
     }
 }
 
-unsafe impl Bindable for PromiseAllRecordHeapData<'_> {
-    type Of<'a> = PromiseAllRecordHeapData<'a>;
+unsafe impl Bindable for PromiseAllRecord<'_> {
+    type Of<'a> = PromiseAllRecord<'a>;
 
     #[inline(always)]
     fn unbind(self) -> Self::Of<'static> {
@@ -115,7 +115,7 @@ unsafe impl Bindable for PromiseAllRecordHeapData<'_> {
     }
 }
 
-impl HeapMarkAndSweep for PromiseAllRecord<'static> {
+impl HeapMarkAndSweep for PromiseAll<'static> {
     fn mark_values(&self, queues: &mut WorkQueues) {
         queues.promise_all_records.push(*self);
     }
@@ -125,8 +125,8 @@ impl HeapMarkAndSweep for PromiseAllRecord<'static> {
     }
 }
 
-unsafe impl Bindable for PromiseAllRecord<'_> {
-    type Of<'a> = PromiseAllRecord<'a>;
+unsafe impl Bindable for PromiseAll<'_> {
+    type Of<'a> = PromiseAll<'a>;
 
     #[inline(always)]
     fn unbind(self) -> Self::Of<'static> {
@@ -139,10 +139,10 @@ unsafe impl Bindable for PromiseAllRecord<'_> {
     }
 }
 
-impl<'a> CreateHeapData<PromiseAllRecordHeapData<'a>, PromiseAllRecord<'a>> for Heap {
-    fn create(&mut self, data: PromiseAllRecordHeapData<'a>) -> PromiseAllRecord<'a> {
+impl<'a> CreateHeapData<PromiseAllRecord<'a>, PromiseAll<'a>> for Heap {
+    fn create(&mut self, data: PromiseAllRecord<'a>) -> PromiseAll<'a> {
         self.promise_all_records.push(Some(data.unbind()));
-        self.alloc_counter += core::mem::size_of::<Option<PromiseAllRecordHeapData<'static>>>();
-        PromiseAllRecord(BaseIndex::last(&self.promise_all_records))
+        self.alloc_counter += core::mem::size_of::<Option<PromiseAllRecord<'static>>>();
+        PromiseAll(BaseIndex::last(&self.promise_all_records))
     }
 }

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_abstract_operations/promise_reaction_records.rs

@@ -10,7 +10,7 @@ use crate::{
             async_generator_objects::AsyncGenerator,
             control_abstraction_objects::async_function_objects::await_reaction::AwaitReaction,
             promise::Promise,
-            promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecord,
+            promise_objects::promise_abstract_operations::promise_all_record::PromiseAll,
         },
         execution::Agent,
         scripts_and_modules::module::module_semantics::{
@@ -71,7 +71,7 @@ pub(crate) enum PromiseReactionHandler<'a> {
     },
     PromiseAll {
         index: u32,
-        promise_all: PromiseAllRecord<'a>,
+        promise_all: PromiseAll<'a>,
     },
     Empty,
 }

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_constructor.rs

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecordHeapData;
+use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecord;
 use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_reaction_records::PromiseReactionHandler;
 use crate::ecmascript::builtins::promise_objects::promise_prototype::inner_promise_then;
 use crate::ecmascript::builtins::Array;
@@ -328,7 +328,7 @@ impl PromiseConstructor {
         let undefined_values = (vec![Value::Undefined.bind(gc.nogc()); 2]).bind(gc.nogc());
         let result_array =
             Array::from_slice(agent, &undefined_values.unbind(), gc.nogc()).bind(gc.nogc());
-        let promise_all_record = agent.heap.create(PromiseAllRecordHeapData {
+        let promise_all_record = agent.heap.create(PromiseAllRecord {
             remaining_unresolved_promise_count: 2,
             result_array: result_array.unbind(),
             promise: result_promise.unbind(),

nova_vm/src/heap.rs

@@ -80,7 +80,7 @@ use crate::{
             },
             primitive_objects::PrimitiveObjectHeapData,
             promise::data::PromiseHeapData,
-            promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecordHeapData,
+            promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecord,
             proxy::data::ProxyHeapData,
             text_processing::string_objects::string_iterator_objects::StringIteratorHeapData,
         },
@@ -169,7 +169,7 @@ pub struct Heap {
     pub promise_reaction_records: Vec<Option<PromiseReactionRecord<'static>>>,
     pub promise_resolving_functions: Vec<Option<PromiseResolvingFunctionHeapData<'static>>>,
     pub promises: Vec<Option<PromiseHeapData<'static>>>,
-    pub promise_all_records: Vec<Option<PromiseAllRecordHeapData<'static>>>,
+    pub promise_all_records: Vec<Option<PromiseAllRecord<'static>>>,
     pub proxys: Vec<Option<ProxyHeapData<'static>>>,
     pub realms: Vec<Option<RealmRecord<'static>>>,
     #[cfg(feature = "regexp")]

nova_vm/src/heap/heap_bits.rs

@@ -50,7 +50,7 @@ use crate::ecmascript::{
         ordinary::{caches::PropertyLookupCache, shape::ObjectShape},
         primitive_objects::PrimitiveObject,
         promise::Promise,
-        promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecord,
+        promise_objects::promise_abstract_operations::promise_all_record::PromiseAll,
         proxy::Proxy,
         text_processing::string_objects::string_iterator_objects::StringIterator,
     },
@@ -210,7 +210,7 @@ pub(crate) struct WorkQueues {
     pub promises: Vec<Promise<'static>>,
     pub promise_reaction_records: Vec<PromiseReaction<'static>>,
     pub promise_resolving_functions: Vec<BuiltinPromiseResolvingFunction<'static>>,
-    pub promise_all_records: Vec<PromiseAllRecord<'static>>,
+    pub promise_all_records: Vec<PromiseAll<'static>>,
     pub proxys: Vec<Proxy<'static>>,
     pub realms: Vec<Realm<'static>>,
     #[cfg(feature = "regexp")]