Allow dead code for code that is newly detected as unused (#3984)

* Allow dead code for code that is newly detected as unused

* Fix compile errors with nightly rust

* Add missing SAFETY section

* Increase safety of `FutexWaiters`

---------

Co-authored-by: Theo Paris <theo@tinted.dev>
Co-authored-by: José Julián Espina <julian.espina@canonical.com>

core/engine/src/builtins/atomics/futex.rs

@@ -139,12 +139,8 @@
 #![allow(clippy::expl_impl_clone_on_copy)]
 #![allow(unstable_name_collisions)]
 
-use std::{
+use std::{cell::UnsafeCell, sync::atomic::Ordering};
-    cell::UnsafeCell,
-    sync::{atomic::Ordering, Condvar, Mutex},
-};
 
-use intrusive_collections::{intrusive_adapter, LinkedList, LinkedListLink, UnsafeRef};
 use sptr::Strict;
 
 use crate::{
@@ -152,34 +148,56 @@ use crate::{
         array_buffer::{utils::SliceRef, SharedArrayBuffer},
         typed_array::Element,
     },
-    small_map::{Entry, SmallMap},
     sys::time::{Duration, Instant},
     JsNativeError, JsResult,
 };
 
-/// Map of shared data addresses and its corresponding list of agents waiting on that location.
+mod sync {
-pub(crate) static CRITICAL_SECTION: Mutex<FutexWaiters> = Mutex::new(FutexWaiters {
+    use std::sync::{Condvar, Mutex, MutexGuard};
-    waiters: SmallMap::new(),
+
-});
+    use intrusive_collections::{intrusive_adapter, LinkedList, LinkedListLink, UnsafeRef};
+
+    use crate::{
+        small_map::{Entry, SmallMap},
+        JsNativeError, JsResult,
+    };
 
-/// A waiter of a memory address.
+    /// A waiter of a memory address.
-#[derive(Debug, Default)]
+    #[derive(Debug, Default)]
-pub(crate) struct FutexWaiter {
+    pub(crate) struct FutexWaiter {
         pub(super) link: LinkedListLink,
         pub(super) cond_var: Condvar,
         pub(super) waiting: bool,
         addr: usize,
-}
+    }
 
-intrusive_adapter!(FutexWaiterAdapter = UnsafeRef<FutexWaiter>: FutexWaiter { link: LinkedListLink });
+    intrusive_adapter!(FutexWaiterAdapter = UnsafeRef<FutexWaiter>: FutexWaiter { link: LinkedListLink });
 
-/// List of memory addresses and its corresponding list of waiters for that address.
+    /// List of memory addresses and its corresponding list of waiters for that address.
-#[derive(Debug)]
+    #[derive(Debug)]
-pub(crate) struct FutexWaiters {
+    pub(super) struct FutexWaiters {
         waiters: SmallMap<usize, LinkedList<FutexWaiterAdapter>, 16>,
-}
+    }
+
+    // SAFETY: `FutexWaiters` is not constructable outside its `get` method, and it's only exposed by
+    //          a global lock, meaning the inner data of `FutexWaiters` (which includes non-Send pointers)
+    //          can only be accessed by a single thread at once.
+    unsafe impl Send for FutexWaiters {}
+
+    impl FutexWaiters {
+        /// Gets the map of all shared data addresses and its corresponding list of agents waiting on that location.
+        pub(super) fn get() -> JsResult<MutexGuard<'static, Self>> {
+            static CRITICAL_SECTION: Mutex<FutexWaiters> = Mutex::new(FutexWaiters {
+                waiters: SmallMap::new(),
+            });
+
+            CRITICAL_SECTION.lock().map_err(|_| {
+                JsNativeError::typ()
+                    .with_message("failed to synchronize with the agent cluster")
+                    .into()
+            })
+        }
 
-impl FutexWaiters {
         /// Notifies at most `max_count` waiters that are waiting on the address `addr`, and
         /// returns the number of waiters that were notified.
         ///
@@ -187,7 +205,7 @@ impl FutexWaiters {
         ///
         /// [remove]: https://tc39.es/ecma262/#sec-removewaiters
         /// [notify]: https://tc39.es/ecma262/#sec-notifywaiter
-    pub(crate) fn notify_many(&mut self, addr: usize, max_count: u64) -> u64 {
+        pub(super) fn notify_many(&mut self, addr: usize, max_count: u64) -> u64 {
             let Entry::Occupied(mut wl) = self.waiters.entry(addr) else {
                 return 0;
             };
@@ -218,7 +236,7 @@ impl FutexWaiters {
         /// - `node` must NOT be linked to an existing waiter list.
         /// - `node` must always point to a valid instance of `FutexWaiter` until `node` is
         ///   removed from its linked list. This can happen by either `remove_waiter` or `notify_many`.
-    pub(crate) unsafe fn add_waiter(&mut self, node: *mut FutexWaiter, addr: usize) {
+        pub(super) unsafe fn add_waiter(&mut self, node: *mut FutexWaiter, addr: usize) {
             // SAFETY: `node` must point to a valid instance.
             let node = unsafe {
                 debug_assert!(!(*node).link.is_linked());
@@ -237,7 +255,7 @@ impl FutexWaiters {
         ///
         /// - `node` must point to a valid instance of `FutexWaiter`.
         /// - `node` must be inside the wait list associated with `node.addr`.
-    pub(crate) unsafe fn remove_waiter(&mut self, node: *mut FutexWaiter) {
+        pub(super) unsafe fn remove_waiter(&mut self, node: *mut FutexWaiter) {
             // SAFETY: `node` must point to a valid instance.
             let addr = unsafe { (*node).addr };
 
@@ -255,6 +273,7 @@ impl FutexWaiters {
                 wl.remove();
             }
         }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -281,10 +300,7 @@ pub(super) unsafe fn wait<E: Element + PartialEq>(
     // 10. Let block be buffer.[[ArrayBufferData]].
     // 11. Let WL be GetWaiterList(block, indexedPosition).
     // 12. Perform EnterCriticalSection(WL).
-    let mut waiters = CRITICAL_SECTION.lock().map_err(|_| {
+    let mut waiters = sync::FutexWaiters::get()?;
-        // avoids exposing internals of our implementation.
-        JsNativeError::typ().with_message("failed to synchronize with the agent cluster")
-    })?;
 
     let time_info = timeout.map(|timeout| (Instant::now(), timeout));
 
@@ -307,7 +323,7 @@ pub(super) unsafe fn wait<E: Element + PartialEq>(
     // 17. Perform AddWaiter(WL, W).
 
     // ensure we can have aliased pointers to the waiter in a sound way.
-    let waiter = UnsafeCell::new(FutexWaiter::default());
+    let waiter = UnsafeCell::new(sync::FutexWaiter::default());
     let waiter_ptr = waiter.get();
 
     // SAFETY: waiter is valid and we call `remove_node` below.
@@ -385,10 +401,7 @@ pub(super) fn notify(buffer: &SharedArrayBuffer, offset: usize, count: u64) -> J
 
     // 7. Let WL be GetWaiterList(block, indexedPosition).
     // 8. Perform EnterCriticalSection(WL).
-    let mut waiters = CRITICAL_SECTION.lock().map_err(|_| {
+    let mut waiters = sync::FutexWaiters::get()?;
-        // avoids exposing internals of our implementation.
-        JsNativeError::typ().with_message("failed to synchronize with the agent cluster")
-    })?;
 
     // 9. Let S be RemoveWaiters(WL, c).
     // 10. For each element W of S, do

core/engine/src/builtins/builder.rs

@@ -16,6 +16,8 @@ use crate::{
 use super::{function::ConstructorKind, BuiltInConstructor, IntrinsicObject};
 
 /// Marker for a constructor function.
+// TODO: Remove this marker and use `Constructor` directly.
+#[allow(dead_code)]
 pub(crate) struct Constructor {
     prototype: JsObject,
     inherits: JsPrototype,
@@ -23,6 +25,8 @@ pub(crate) struct Constructor {
 }
 
 /// Marker for a constructor function without a custom prototype for its instances.
+// TODO: Remove this marker and use `ConstructorNoProto` directly.
+#[allow(dead_code)]
 pub(crate) struct ConstructorNoProto;
 
 /// Marker for an ordinary function.