chore: fix typos, lint, and update test262

.github/workflows/ci.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@nightly
         with:
-          toolchain: nightly-2026-05-28
+          toolchain: nightly-2026-10-01
           components: rustfmt, clippy, llvm-tools-preview, rustc-dev
       - name: Cache on ${{ github.ref_name }}
         uses: Swatinem/rust-cache@v2
@@ -50,17 +50,17 @@ jobs:
       - name: Install cargo-dylint
         uses: taiki-e/cache-cargo-install-action@v2
         with:
-          tool: cargo-dylint@6.0.1
+          tool: cargo-dylint@6.2.0
       - name: Install dylint-link
         uses: taiki-e/cache-cargo-install-action@v2
         with:
-          tool: dylint-link@6.0.1
+          tool: dylint-link@6.2.0
       - name: Check formatting
         run: cargo fmt --check
       - name: Clippy
         run: |
           cargo +stable clippy --all-targets -- -D warnings
-          cargo +nightly-2026-05-28 clippy --all-targets --all-features -- -D warnings
+          cargo +nightly-2026-10-01 clippy --all-targets --all-features -- -D warnings
       - name: Dylint tests
         working-directory: nova_lint
         run: cargo test

Cargo.toml

@@ -16,9 +16,9 @@ authors = ["The Nova Team"]
 
 [workspace.dependencies]
 ahash = "=0.8.12"
-clap = { version = "=4.6.0", features = ["derive"] }
-cliclack = "=0.5.4"
-console = "=0.16.3"
+clap = { version = "=4.6.7", features = ["derive"] }
+cliclack = "=0.5.6"
+console = "=0.16.6"
 ctrlc = "=3.5.2"
 ecmascript_atomics = { version = "=0.2.3" }
 fast-float = "=0.2.0"
@@ -29,7 +29,7 @@ lexical = { version = "=7.0.5", default-features = false, features = [
     "write-floats",
     "radix",
 ] }
-num-bigint = "=0.4.6"
+num-bigint = "=0.5.1"
 num-traits = "=0.2.19"
 oxc-miette = { version = "=2.7.1", features = ["fancy"] }
 oxc_allocator = "=0.124.0"
@@ -41,17 +41,17 @@ oxc_regular_expression = "=0.124.0"
 oxc_semantic = "=0.124.0"
 oxc_span = "=0.124.0"
 oxc_syntax = "=0.124.0"
-rand = "=0.10.1"
-regex = "=1.12.3"
-ryu-js = "=1.0.2"
+rand = "=0.10.3"
+regex = "=1.13.1"
+ryu-js = "=1.0.3"
 soavec = "=0.2.0"
 soavec_derive = "=0.2.0"
-sonic-rs = "=0.5.8"
-unicode-normalization = "=0.1.25"
+sonic-rs = "=0.5.10"
+unicode-normalization = "=0.1.26"
 usdt = "=0.6.0"
 wtf8 = "=0.1.0"
 xsum = "=0.1.6"
-temporal_rs = "=0.2.3"
+temporal_rs = "=0.2.6"
 
 [workspace.metadata.dylint]
 libraries = [{ path = "nova_lint" }]

nova_lint/Cargo.toml

@@ -47,9 +47,9 @@ path = "ui/spec_header_level.rs"
 [dependencies]
 # Must match the nightly toolchain pinned in .github/workflows/ci.yml: each
 # clippy_utils release only builds with its contemporary nightly.
-clippy_utils = "0.1.98"
-dylint_linting = { version = "6.0.1", features = ["constituent"] }
-regex = "1"
+clippy_utils = "=0.1.101"
+dylint_linting = { version = "=6.2.0", features = ["constituent"] }
+regex = "=1.13.1"
 
 [dev-dependencies]
 dylint_testing = "6.0.1"

nova_lint/rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2026-05-28"
+channel = "nightly-2026-10-01"
 components = ["llvm-tools-preview", "rustc-dev"]

nova_lint/src/can_use_no_gc_scope.rs

@@ -1,13 +1,13 @@
 use std::ops::ControlFlow;
 
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, fn_def_id, is_trait_impl_item, source::HasSession,
+    diagnostics::span_lint_and_sugg, fn_def_id, is_trait_impl_item,
     visitors::for_each_expr,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, def::Res, def_id::LocalDefId, intravisit::FnKind};
 use rustc_hir_analysis::lower_ty;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_span::{BytePos, Span};
 
 use crate::{could_be_builtin_method_def, is_gc_scope_ty, is_no_gc_method, is_trait_item};
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for CanUseNoGcScope {
             return;
         };
 
-        if for_each_expr(cx, body.value, |expr| {
+        if for_each_expr(cx.tcx, body.value, |expr| {
             // Checks if the expression is function or method call
             if let Some(did) = fn_def_id(cx, expr)
                 // If we encountered either a `nogc` och `into_nogc` method call

nova_lint/src/immediately_bind_scoped.rs

@@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for ImmediatelyBindScoped {
                     // Check each expression in the current statement for use
                     // of the value, breaking when found and optionally marking
                     // it as valid.
-                    if for_each_expr(cx, stmt_expr, |expr_in_stmt| {
+                    if for_each_expr(cx.tcx, stmt_expr, |expr_in_stmt| {
                         if expr_in_stmt.res_local_id() == Some(local_hir_id) {
                             if is_valid_use_of_unbound_value(cx, expr_in_stmt, local_hir_id) {
                                 found_valid_next_use = true;

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

@@ -16,7 +16,6 @@ use std::{
 };
 
 use core::{
-    f32, f64,
     mem::MaybeUninit,
     ops::{Deref, DerefMut},
     ptr::{NonNull, read_unaligned, write_unaligned},
@@ -758,7 +757,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,
                 );
             });

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.95.0"
+channel = "1.99.1"
 components = ["rustfmt", "clippy"]