chore: fix typos, lint, and update test262

nova_vm/src/ecmascript/builtins/finalization_registry.rs

@@ -32,7 +32,7 @@ arena_vec_access!(
     FinalizationRegistry,
     'a,
     FinalizationRegistryRecord,
-    finalization_registrys,
+    finalization_registries,
     FinalizationRegistryRecordRef,
     FinalizationRegistryRecordMut
 );
@@ -65,7 +65,7 @@ impl<'fr> FinalizationRegistry<'fr> {
     pub(crate) fn enqueue_cleanup_jobs(agent: &mut Agent) {
         let frs_to_enqueue = agent
             .heap
-            .finalization_registrys
+            .finalization_registries
             .as_mut_slice()
             .cleanup
             .iter_mut()
@@ -147,8 +147,8 @@ impl<'a> InternalMethods<'a> for FinalizationRegistry<'a> {}
 
 impl<'a> CreateHeapData<FinalizationRegistryRecord<'a>, FinalizationRegistry<'a>> for Heap {
     fn create(&mut self, data: FinalizationRegistryRecord<'a>) -> FinalizationRegistry<'a> {
-        let i = self.finalization_registrys.len();
-        self.finalization_registrys
+        let i = self.finalization_registries.len();
+        self.finalization_registries
             .push(data.unbind())
             .expect("Failed to allocate FinalizationRegistry");
         self.alloc_counter += core::mem::size_of::<FinalizationRegistryRecord<'static>>();
@@ -158,18 +158,18 @@ impl<'a> CreateHeapData<FinalizationRegistryRecord<'a>, FinalizationRegistry<'a>
 
 impl HeapMarkAndSweep for FinalizationRegistry<'static> {
     fn mark_values(&self, queues: &mut WorkQueues) {
-        queues.finalization_registrys.push(*self);
+        queues.finalization_registries.push(*self);
     }
 
     fn sweep_values(&mut self, compactions: &CompactionLists) {
-        compactions.finalization_registrys.shift_index(&mut self.0);
+        compactions.finalization_registries.shift_index(&mut self.0);
     }
 }
 
 impl HeapSweepWeakReference for FinalizationRegistry<'static> {
     fn sweep_weak_reference(self, compactions: &CompactionLists) -> Option<Self> {
         compactions
-            .finalization_registrys
+            .finalization_registries
             .shift_weak_index(self.0)
             .map(Self)
     }

nova_vm/src/ecmascript/types/spec/data_block.rs

@@ -758,7 +758,7 @@ impl Drop for SharedDataBlock {
         // containing the byte data.
         let _ = unsafe { memory.exit() };
         // SAFETY: layout guaranteed by type.
-        let layout = unsafe { Layout::from_size_align(size, 8).unwrap_unchecked() };
+        let layout = unsafe { Layout::from_size_align_unchecked(size, 8) };
         unsafe { dealloc(base_ptr.cast::<u8>().as_ptr(), layout) }
     }
 }

nova_vm/src/heap.rs

@@ -98,7 +98,7 @@ pub(crate) struct Heap {
     pub(crate) errors: Vec<ErrorHeapData<'static>>,
     /// Stores compiled bytecodes
     pub(crate) executables: Vec<ExecutableHeapData<'static>>,
-    pub(crate) finalization_registrys: SoAVec<FinalizationRegistryRecord<'static>>,
+    pub(crate) finalization_registries: SoAVec<FinalizationRegistryRecord<'static>>,
     pub(crate) generators: Vec<GeneratorHeapData<'static>>,
     pub(crate) globals: RefCell<Vec<HeapRootData>>,
     pub(crate) maps: SoAVec<MapHeapData<'static>>,
@@ -271,7 +271,7 @@ impl Heap {
             errors: Vec::with_capacity(1024),
             executables: Vec::with_capacity(1024),
             source_codes: Vec::with_capacity(0),
-            finalization_registrys: SoAVec::with_capacity(0).expect("Failed to allocate Heap"),
+            finalization_registries: SoAVec::with_capacity(0).expect("Failed to allocate Heap"),
             generators: Vec::with_capacity(1024),
             globals: RefCell::new(Vec::with_capacity(1024)),
             maps: SoAVec::with_capacity(128).expect("Failed to allocate Heap"),

nova_vm/src/heap/heap_bits.rs

@@ -429,7 +429,7 @@ pub(crate) struct HeapBits {
     pub(super) errors: BitRange,
     pub(super) executables: BitRange,
     pub(super) source_codes: BitRange,
-    pub(super) finalization_registrys: BitRange,
+    pub(super) finalization_registries: BitRange,
     pub(super) function_environments: BitRange,
     pub(super) generators: BitRange,
     pub(super) global_environments: BitRange,
@@ -533,7 +533,7 @@ pub(crate) struct WorkQueues<'a> {
     pub(crate) source_codes: Vec<SourceCode<'static>>,
     pub(crate) errors: Vec<Error<'static>>,
     pub(crate) executables: Vec<Executable<'static>>,
-    pub(crate) finalization_registrys: Vec<FinalizationRegistry<'static>>,
+    pub(crate) finalization_registries: Vec<FinalizationRegistry<'static>>,
     pub(crate) function_environments: Vec<FunctionEnvironment<'static>>,
     pub(crate) generators: Vec<Generator<'static>>,
     pub(crate) global_environments: Vec<GlobalEnvironment<'static>>,
@@ -670,9 +670,9 @@ impl HeapBits {
         let executables = BitRange::from_bit_count_and_len(&mut bit_count, heap.executables.len());
         let source_codes =
             BitRange::from_bit_count_and_len(&mut bit_count, heap.source_codes.len());
-        let finalization_registrys = BitRange::from_bit_count_and_len(
+        let finalization_registries = BitRange::from_bit_count_and_len(
             &mut bit_count,
-            heap.finalization_registrys.len() as usize,
+            heap.finalization_registries.len() as usize,
         );
         let function_environments =
             BitRange::from_bit_count_and_len(&mut bit_count, heap.environments.function.len());
@@ -801,7 +801,7 @@ impl HeapBits {
             errors,
             executables,
             source_codes,
-            finalization_registrys,
+            finalization_registries,
             function_environments,
             generators,
             global_environments,
@@ -891,7 +891,7 @@ impl HeapBits {
             WeakKey::PlainTime(d) => self.plain_times.get_bit(d.get_index(), &self.bits),
             WeakKey::Error(d) => self.errors.get_bit(d.get_index(), &self.bits),
             WeakKey::FinalizationRegistry(d) => self
-                .finalization_registrys
+                .finalization_registries
                 .get_bit(d.get_index(), &self.bits),
             WeakKey::Map(d) => self.maps.get_bit(d.get_index(), &self.bits),
             WeakKey::Promise(d) => self.promises.get_bit(d.get_index(), &self.bits),
@@ -1060,8 +1060,8 @@ impl<'a> WorkQueues<'a> {
             errors: Vec::with_capacity(heap.errors.len() / 4),
             executables: Vec::with_capacity(heap.executables.len() / 4),
             source_codes: Vec::with_capacity(heap.source_codes.len() / 4),
-            finalization_registrys: Vec::with_capacity(
-                heap.finalization_registrys.len() as usize / 4,
+            finalization_registries: Vec::with_capacity(
+                heap.finalization_registries.len() as usize / 4,
             ),
             function_environments: Vec::with_capacity(heap.environments.function.len() / 4),
             generators: Vec::with_capacity(heap.generators.len() / 4),
@@ -1172,7 +1172,7 @@ impl<'a> WorkQueues<'a> {
             source_codes,
             errors,
             executables,
-            finalization_registrys,
+            finalization_registries,
             function_environments,
             generators,
             global_environments,
@@ -1300,7 +1300,7 @@ impl<'a> WorkQueues<'a> {
             && errors.is_empty()
             && executables.is_empty()
             && source_codes.is_empty()
-            && finalization_registrys.is_empty()
+            && finalization_registries.is_empty()
             && function_environments.is_empty()
             && generators.is_empty()
             && global_environments.is_empty()
@@ -1666,7 +1666,7 @@ pub(crate) struct CompactionLists {
     pub(crate) source_text_module_records: CompactionList,
     pub(crate) errors: CompactionList,
     pub(crate) executables: CompactionList,
-    pub(crate) finalization_registrys: CompactionList,
+    pub(crate) finalization_registries: CompactionList,
     pub(crate) function_environments: CompactionList,
     pub(crate) generators: CompactionList,
     pub(crate) global_environments: CompactionList,
@@ -1867,8 +1867,8 @@ impl CompactionLists {
             symbols: CompactionList::from_mark_bits(&bits.symbols, &bits.bits),
             #[cfg(feature = "array-buffer")]
             data_views: CompactionList::from_mark_bits(&bits.data_views, &bits.bits),
-            finalization_registrys: CompactionList::from_mark_bits(
-                &bits.finalization_registrys,
+            finalization_registries: CompactionList::from_mark_bits(
+                &bits.finalization_registries,
                 &bits.bits,
             ),
             proxies: CompactionList::from_mark_bits(&bits.proxies, &bits.bits),

nova_vm/src/heap/heap_gc.rs

@@ -63,7 +63,7 @@ pub(crate) fn heap_gc(agent: &mut Agent, root_realms: &mut [Option<Realm<'static
     agent.heap.prototype_shapes.mark_values(&mut queues);
     agent.heap.caches.mark_values(&mut queues);
     agent.mark_values(&mut queues);
-    let mut has_finalization_registrys = false;
+    let mut has_finalization_registries = false;
 
     while !queues.is_empty() {
         let Heap {
@@ -95,7 +95,7 @@ pub(crate) fn heap_gc(agent: &mut Agent, root_realms: &mut [Option<Realm<'static
             errors,
             executables,
             source_codes,
-            finalization_registrys,
+            finalization_registries,
             generators,
             globals: _,
             maps,
@@ -567,19 +567,19 @@ pub(crate) fn heap_gc(agent: &mut Agent, root_realms: &mut [Option<Realm<'static
                 }
             });
         }
-        if !queues.finalization_registrys.is_empty() {
+        if !queues.finalization_registries.is_empty() {
             let mut finalization_registry_marks: Box<[FinalizationRegistry]> =
-                queues.finalization_registrys.drain(..).collect();
+                queues.finalization_registries.drain(..).collect();
             finalization_registry_marks.sort();
             if !finalization_registry_marks.is_empty() {
-                has_finalization_registrys = true;
+                has_finalization_registries = true;
             }
             finalization_registry_marks.iter().for_each(|&idx| {
                 let index = idx.get_index();
-                if bits.finalization_registrys.set_bit(index, &bits.bits) {
+                if bits.finalization_registries.set_bit(index, &bits.bits) {
                     // Did mark.
 
-                    finalization_registrys
+                    finalization_registries
                         .get(index as u32)
                         .mark_values(&mut queues);
                 }
@@ -1221,7 +1221,7 @@ pub(crate) fn heap_gc(agent: &mut Agent, root_realms: &mut [Option<Realm<'static
     }
 
     sweep(agent, &bits, root_realms, gc);
-    if has_finalization_registrys {
+    if has_finalization_registries {
         FinalizationRegistry::enqueue_cleanup_jobs(agent);
     }
     ndt::gc_done!(|| ());
@@ -1273,7 +1273,7 @@ fn sweep(
         errors,
         executables,
         source_codes,
-        finalization_registrys,
+        finalization_registries,
         generators,
         globals,
         maps,
@@ -1777,12 +1777,12 @@ fn sweep(
                 sweep_heap_vector_values(executables, &compactions, &bits.executables, &bits.bits);
             });
         }
-        if !finalization_registrys.is_empty() {
+        if !finalization_registries.is_empty() {
             s.spawn(|| {
                 sweep_heap_soa_vector_values(
-                    finalization_registrys,
+                    finalization_registries,
                     &compactions,
-                    &bits.finalization_registrys,
+                    &bits.finalization_registries,
                     &bits.bits,
                 );
             });