html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/tokio/src/util/sharded_list.rs

@@ -0,0 +1,162 @@
+use std::ptr::NonNull;
+use std::sync::atomic::Ordering;
+
+use crate::loom::sync::{Mutex, MutexGuard};
+use crate::util::metric_atomics::{MetricAtomicU64, MetricAtomicUsize};
+
+use super::linked_list::{Link, LinkedList};
+
+/// An intrusive linked list supporting highly concurrent updates.
+///
+/// It currently relies on `LinkedList`, so it is the caller's
+/// responsibility to ensure the list is empty before dropping it.
+///
+/// Note: Due to its inner sharded design, the order of nodes cannot be guaranteed.
+pub(crate) struct ShardedList<L, T> {
+    lists: Box<[Mutex<LinkedList<L, T>>]>,
+    added: MetricAtomicU64,
+    count: MetricAtomicUsize,
+    shard_mask: usize,
+}
+
+/// Determines which linked list an item should be stored in.
+///
+/// # Safety
+///
+/// Implementations must guarantee that the id of an item does not change from
+/// call to call.
+pub(crate) unsafe trait ShardedListItem: Link {
+    /// # Safety
+    ///
+    /// The provided pointer must point at a valid list item.
+    unsafe fn get_shard_id(target: NonNull<Self::Target>) -> usize;
+}
+
+impl<L, T> ShardedList<L, T> {
+    /// Creates a new and empty sharded linked list with the specified size.
+    pub(crate) fn new(sharded_size: usize) -> Self {
+        assert!(sharded_size.is_power_of_two());
+
+        let shard_mask = sharded_size - 1;
+        let mut lists = Vec::with_capacity(sharded_size);
+        for _ in 0..sharded_size {
+            lists.push(Mutex::new(LinkedList::<L, T>::new()))
+        }
+        Self {
+            lists: lists.into_boxed_slice(),
+            added: MetricAtomicU64::new(0),
+            count: MetricAtomicUsize::new(0),
+            shard_mask,
+        }
+    }
+}
+
+/// Used to get the lock of shard.
+pub(crate) struct ShardGuard<'a, L, T> {
+    lock: MutexGuard<'a, LinkedList<L, T>>,
+    added: &'a MetricAtomicU64,
+    count: &'a MetricAtomicUsize,
+    id: usize,
+}
+
+impl<L: ShardedListItem> ShardedList<L, L::Target> {
+    /// Removes the last element from a list specified by `shard_id` and returns it, or None if it is
+    /// empty.
+    pub(crate) fn pop_back(&self, shard_id: usize) -> Option<L::Handle> {
+        let mut lock = self.shard_inner(shard_id);
+        let node = lock.pop_back();
+        if node.is_some() {
+            self.count.decrement();
+        }
+        node
+    }
+
+    /// Removes the specified node from the list.
+    ///
+    /// # Safety
+    ///
+    /// The caller **must** ensure that exactly one of the following is true:
+    /// - `node` is currently contained by `self`,
+    /// - `node` is not contained by any list,
+    /// - `node` is currently contained by some other `GuardedLinkedList`.
+    pub(crate) unsafe fn remove(&self, node: NonNull<L::Target>) -> Option<L::Handle> {
+        let id = unsafe { L::get_shard_id(node) };
+        let mut lock = self.shard_inner(id);
+        // SAFETY: Since the shard id cannot change, it's not possible for this node
+        // to be in any other list of the same sharded list.
+        let node = unsafe { lock.remove(node) };
+        if node.is_some() {
+            self.count.decrement();
+        }
+        node
+    }
+
+    /// Gets the lock of `ShardedList`, makes us have the write permission.
+    pub(crate) fn lock_shard(&self, val: &L::Handle) -> ShardGuard<'_, L, L::Target> {
+        let id = unsafe { L::get_shard_id(L::as_raw(val)) };
+        ShardGuard {
+            lock: self.shard_inner(id),
+            added: &self.added,
+            count: &self.count,
+            id,
+        }
+    }
+
+    /// Gets the count of elements in this list.
+    pub(crate) fn len(&self) -> usize {
+        self.count.load(Ordering::Relaxed)
+    }
+
+    cfg_64bit_metrics! {
+        /// Gets the total number of elements added to this list.
+        pub(crate) fn added(&self) -> u64 {
+            self.added.load(Ordering::Relaxed)
+        }
+    }
+
+    /// Returns whether the linked list does not contain any node.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Gets the shard size of this `SharedList`.
+    ///
+    /// Used to help us to decide the parameter `shard_id` of the `pop_back` method.
+    pub(crate) fn shard_size(&self) -> usize {
+        self.shard_mask + 1
+    }
+
+    #[inline]
+    fn shard_inner(&self, id: usize) -> MutexGuard<'_, LinkedList<L, <L as Link>::Target>> {
+        // Safety: This modulo operation ensures that the index is not out of bounds.
+        unsafe { self.lists.get_unchecked(id & self.shard_mask).lock() }
+    }
+}
+
+impl<'a, L: ShardedListItem> ShardGuard<'a, L, L::Target> {
+    /// Push a value to this shard.
+    pub(crate) fn push(mut self, val: L::Handle) {
+        let id = unsafe { L::get_shard_id(L::as_raw(&val)) };
+        assert_eq!(id, self.id);
+        self.lock.push_front(val);
+        self.added.add(1, Ordering::Relaxed);
+        self.count.increment();
+    }
+}
+
+cfg_taskdump! {
+    impl<L: ShardedListItem> ShardedList<L, L::Target> {
+        pub(crate) fn for_each<F>(&self, mut f: F)
+        where
+            F: FnMut(&L::Handle),
+        {
+            let mut guards = Vec::with_capacity(self.lists.len());
+            for list in self.lists.iter() {
+                guards.push(list.lock());
+            }
+            for g in &mut guards {
+                g.for_each(&mut f);
+            }
+        }
+    }
+}

data/rust-vendor/tokio/src/util/sync_wrapper.rs

@@ -0,0 +1,37 @@
+//! This module contains a type that can make `Send + !Sync` types `Sync` by
+//! disallowing all immutable access to the value.
+//!
+//! A similar primitive is provided in the `sync_wrapper` crate.
+
+use std::any::Any;
+
+pub(crate) struct SyncWrapper<T> {
+    value: T,
+}
+
+// safety: The SyncWrapper being send allows you to send the inner value across
+// thread boundaries.
+unsafe impl<T: Send> Send for SyncWrapper<T> {}
+
+// safety: An immutable reference to a SyncWrapper is useless, so moving such an
+// immutable reference across threads is safe.
+unsafe impl<T> Sync for SyncWrapper<T> {}
+
+impl<T> SyncWrapper<T> {
+    pub(crate) fn new(value: T) -> Self {
+        Self { value }
+    }
+
+    pub(crate) fn into_inner(self) -> T {
+        self.value
+    }
+}
+
+impl SyncWrapper<Box<dyn Any + Send>> {
+    /// Attempt to downcast using `Any::downcast_ref()` to a type that is known to be `Sync`.
+    pub(crate) fn downcast_ref_sync<T: Any + Sync>(&self) -> Option<&T> {
+        // SAFETY: if the downcast fails, the inner value is not touched,
+        // so no thread-safety violation can occur.
+        self.value.downcast_ref()
+    }
+}

data/rust-vendor/tokio/src/util/trace.rs

@@ -0,0 +1,191 @@
+cfg_rt! {
+    use std::marker::PhantomData;
+
+    #[derive(Copy, Clone)]
+    pub(crate) struct SpawnMeta<'a> {
+        /// The name of the task
+        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        pub(crate) name: Option<&'a str>,
+        /// The original size of the future or function being spawned
+        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        pub(crate) original_size: usize,
+        /// The source code location where the task was spawned.
+        ///
+        /// This is wrapped in a type that may be empty when `tokio_unstable` is
+        /// not enabled.
+        pub(crate) spawned_at: crate::runtime::task::SpawnLocation,
+        _pd: PhantomData<&'a ()>,
+    }
+
+    impl<'a> SpawnMeta<'a> {
+        /// Create new spawn meta with a name and original size (before possible auto-boxing)
+        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        #[track_caller]
+        pub(crate) fn new(name: Option<&'a str>, original_size: usize) -> Self {
+            Self {
+                name,
+                original_size,
+                spawned_at: crate::runtime::task::SpawnLocation::capture(),
+                _pd: PhantomData,
+            }
+        }
+
+        /// Create a new unnamed spawn meta with the original size (before possible auto-boxing)
+        #[track_caller]
+        pub(crate) fn new_unnamed(original_size: usize) -> Self {
+            #[cfg(not(all(tokio_unstable, feature = "tracing")))]
+            let _original_size = original_size;
+
+            Self {
+                #[cfg(all(tokio_unstable, feature = "tracing"))]
+                name: None,
+                #[cfg(all(tokio_unstable, feature = "tracing"))]
+                original_size,
+                spawned_at: crate::runtime::task::SpawnLocation::capture(),
+                _pd: PhantomData,
+            }
+        }
+    }
+
+    cfg_trace! {
+        use core::{
+            pin::Pin,
+            task::{Context, Poll},
+        };
+        use pin_project_lite::pin_project;
+        use std::mem;
+        use std::future::Future;
+        use tracing::instrument::Instrument;
+        pub(crate) use tracing::instrument::Instrumented;
+
+        #[inline]
+        pub(crate) fn task<F>(task: F, kind: &'static str, meta: SpawnMeta<'_>, id: u64) -> Instrumented<F> {
+            fn get_span(kind: &'static str, spawn_meta: SpawnMeta<'_>, id: u64, task_size: usize) -> tracing::Span {
+                let original_size = if spawn_meta.original_size != task_size {
+                    Some(spawn_meta.original_size)
+                } else {
+                    None
+                };
+                tracing::trace_span!(
+                    target: "tokio::task",
+                    parent: None,
+                    "runtime.spawn",
+                    %kind,
+                    task.name = %spawn_meta.name.unwrap_or_default(),
+                    task.id = id,
+                    original_size.bytes = original_size,
+                    size.bytes = task_size,
+                    loc.file = spawn_meta.spawned_at.0.file(),
+                    loc.line = spawn_meta.spawned_at.0.line(),
+                    loc.col = spawn_meta.spawned_at.0.column(),
+                )
+            }
+            use tracing::instrument::Instrument;
+            let span = get_span(kind, meta, id, mem::size_of::<F>());
+            task.instrument(span)
+        }
+
+        #[inline]
+        pub(crate) fn blocking_task<Fn, Fut>(task: Fut, spawn_meta: SpawnMeta<'_>, id: u64) -> Instrumented<Fut> {
+            let fn_size = mem::size_of::<Fn>();
+            let original_size = if spawn_meta.original_size != fn_size {
+                Some(spawn_meta.original_size)
+            } else {
+                None
+            };
+
+            let span = tracing::trace_span!(
+                target: "tokio::task::blocking",
+                "runtime.spawn",
+                kind = %"blocking",
+                task.name = %spawn_meta.name.unwrap_or_default(),
+                task.id = id,
+                "fn" = %std::any::type_name::<Fn>(),
+                original_size.bytes = original_size,
+                size.bytes = fn_size,
+                loc.file = spawn_meta.spawned_at.0.file(),
+                loc.line = spawn_meta.spawned_at.0.line(),
+                loc.col = spawn_meta.spawned_at.0.column(),
+            );
+            task.instrument(span)
+
+        }
+
+        pub(crate) fn async_op<P,F>(inner: P, resource_span: tracing::Span, source: &str, poll_op_name: &'static str, inherits_child_attrs: bool) -> InstrumentedAsyncOp<F>
+        where P: FnOnce() -> F {
+            resource_span.in_scope(|| {
+                let async_op_span = tracing::trace_span!("runtime.resource.async_op", source = source, inherits_child_attrs = inherits_child_attrs);
+                let enter = async_op_span.enter();
+                let async_op_poll_span = tracing::trace_span!("runtime.resource.async_op.poll");
+                let inner = inner();
+                drop(enter);
+                let tracing_ctx = AsyncOpTracingCtx {
+                    async_op_span,
+                    async_op_poll_span,
+                    resource_span: resource_span.clone(),
+                };
+                InstrumentedAsyncOp {
+                    inner,
+                    tracing_ctx,
+                    poll_op_name,
+                }
+            })
+        }
+
+        #[derive(Debug, Clone)]
+        pub(crate) struct AsyncOpTracingCtx {
+            pub(crate) async_op_span: tracing::Span,
+            pub(crate) async_op_poll_span: tracing::Span,
+            pub(crate) resource_span: tracing::Span,
+        }
+
+
+        pin_project! {
+            #[derive(Debug, Clone)]
+            pub(crate) struct InstrumentedAsyncOp<F> {
+                #[pin]
+                pub(crate) inner: F,
+                pub(crate) tracing_ctx: AsyncOpTracingCtx,
+                pub(crate) poll_op_name: &'static str
+            }
+        }
+
+        impl<F: Future> Future for InstrumentedAsyncOp<F> {
+            type Output = F::Output;
+
+            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let this = self.project();
+                let poll_op_name = &*this.poll_op_name;
+                let _res_enter = this.tracing_ctx.resource_span.enter();
+                let _async_op_enter = this.tracing_ctx.async_op_span.enter();
+                let _async_op_poll_enter = this.tracing_ctx.async_op_poll_span.enter();
+                trace_poll_op!(poll_op_name, this.inner.poll(cx))
+            }
+        }
+    }
+
+    cfg_not_trace! {
+        #[inline]
+        pub(crate) fn task<F>(task: F, _kind: &'static str, _meta: SpawnMeta<'_>, _id: u64) -> F {
+            // nop
+            task
+        }
+
+        #[inline]
+        pub(crate) fn blocking_task<Fn, Fut>(task: Fut, _spawn_meta: SpawnMeta<'_>, _id: u64) -> Fut {
+            let _ = PhantomData::<&Fn>;
+            // nop
+            task
+        }
+    }
+}
+
+cfg_time! {
+    #[track_caller]
+    pub(crate) fn caller_location() -> Option<&'static std::panic::Location<'static>> {
+        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        return Some(std::panic::Location::caller());
+        #[cfg(not(all(tokio_unstable, feature = "tracing")))]
+        None
+    }
+}

data/rust-vendor/tokio/src/util/try_lock.rs

@@ -0,0 +1,80 @@
+use crate::loom::sync::atomic::AtomicBool;
+
+use std::cell::UnsafeCell;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::sync::atomic::Ordering::SeqCst;
+
+pub(crate) struct TryLock<T> {
+    locked: AtomicBool,
+    data: UnsafeCell<T>,
+}
+
+pub(crate) struct LockGuard<'a, T> {
+    lock: &'a TryLock<T>,
+    _p: PhantomData<std::rc::Rc<()>>,
+}
+
+unsafe impl<T: Send> Send for TryLock<T> {}
+unsafe impl<T: Send> Sync for TryLock<T> {}
+
+unsafe impl<T: Sync> Sync for LockGuard<'_, T> {}
+
+macro_rules! new {
+    ($data:ident) => {
+        TryLock {
+            locked: AtomicBool::new(false),
+            data: UnsafeCell::new($data),
+        }
+    };
+}
+
+impl<T> TryLock<T> {
+    #[cfg(not(loom))]
+    /// Create a new `TryLock`
+    pub(crate) const fn new(data: T) -> TryLock<T> {
+        new!(data)
+    }
+
+    #[cfg(loom)]
+    /// Create a new `TryLock`
+    pub(crate) fn new(data: T) -> TryLock<T> {
+        new!(data)
+    }
+
+    /// Attempt to acquire lock
+    pub(crate) fn try_lock(&self) -> Option<LockGuard<'_, T>> {
+        if self
+            .locked
+            .compare_exchange(false, true, SeqCst, SeqCst)
+            .is_err()
+        {
+            return None;
+        }
+
+        Some(LockGuard {
+            lock: self,
+            _p: PhantomData,
+        })
+    }
+}
+
+impl<T> Deref for LockGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.data.get() }
+    }
+}
+
+impl<T> DerefMut for LockGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.data.get() }
+    }
+}
+
+impl<T> Drop for LockGuard<'_, T> {
+    fn drop(&mut self) {
+        self.lock.locked.store(false, SeqCst);
+    }
+}

data/rust-vendor/tokio/src/util/typeid.rs

@@ -0,0 +1,45 @@
+use std::{
+    any::TypeId,
+    marker::PhantomData,
+    mem::{self, ManuallyDrop},
+};
+
+// SAFETY: this function does not compare lifetimes. Values returned as `Ok`
+// may have their lifetimes extended.
+pub(super) unsafe fn try_transmute<Src, Target: 'static>(x: Src) -> Result<Target, Src> {
+    if nonstatic_typeid::<Src>() == TypeId::of::<Target>() {
+        let x = ManuallyDrop::new(x);
+        // SAFETY: we have checked that the types are the same.
+        Ok(unsafe { mem::transmute_copy::<Src, Target>(&x) })
+    } else {
+        Err(x)
+    }
+}
+
+// https://github.com/dtolnay/typeid/blob/b06a3c08a0eaccc7df6091ade1ae4e3fb53609d5/src/lib.rs#L197-L222
+#[inline(always)]
+fn nonstatic_typeid<T>() -> TypeId
+where
+    T: ?Sized,
+{
+    trait NonStaticAny {
+        fn get_type_id(&self) -> TypeId
+        where
+            Self: 'static;
+    }
+
+    impl<T: ?Sized> NonStaticAny for PhantomData<T> {
+        #[inline(always)]
+        fn get_type_id(&self) -> TypeId
+        where
+            Self: 'static,
+        {
+            TypeId::of::<T>()
+        }
+    }
+
+    let phantom_data = PhantomData::<T>;
+    NonStaticAny::get_type_id(unsafe {
+        mem::transmute::<&dyn NonStaticAny, &(dyn NonStaticAny + 'static)>(&phantom_data)
+    })
+}

data/rust-vendor/tokio/src/util/wake.rs

@@ -0,0 +1,78 @@
+use crate::loom::sync::Arc;
+
+use std::marker::PhantomData;
+use std::mem::ManuallyDrop;
+use std::ops::Deref;
+use std::task::{RawWaker, RawWakerVTable, Waker};
+
+/// Simplified waking interface based on Arcs.
+pub(crate) trait Wake: Send + Sync + Sized + 'static {
+    /// Wake by value.
+    fn wake(arc_self: Arc<Self>);
+
+    /// Wake by reference.
+    fn wake_by_ref(arc_self: &Arc<Self>);
+}
+
+/// A `Waker` that is only valid for a given lifetime.
+#[derive(Debug)]
+pub(crate) struct WakerRef<'a> {
+    waker: ManuallyDrop<Waker>,
+    _p: PhantomData<&'a ()>,
+}
+
+impl Deref for WakerRef<'_> {
+    type Target = Waker;
+
+    fn deref(&self) -> &Waker {
+        &self.waker
+    }
+}
+
+/// Creates a reference to a `Waker` from a reference to `Arc<impl Wake>`.
+pub(crate) fn waker_ref<W: Wake>(wake: &Arc<W>) -> WakerRef<'_> {
+    let ptr = Arc::as_ptr(wake).cast::<()>();
+
+    let waker = unsafe { Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>())) };
+
+    WakerRef {
+        waker: ManuallyDrop::new(waker),
+        _p: PhantomData,
+    }
+}
+
+fn waker_vtable<W: Wake>() -> &'static RawWakerVTable {
+    &RawWakerVTable::new(
+        clone_arc_raw::<W>,
+        wake_arc_raw::<W>,
+        wake_by_ref_arc_raw::<W>,
+        drop_arc_raw::<W>,
+    )
+}
+
+unsafe fn clone_arc_raw<T: Wake>(data: *const ()) -> RawWaker {
+    // Safety: `data` was created from an `Arc::as_ptr` in function `waker_ref`.
+    unsafe {
+        Arc::<T>::increment_strong_count(data as *const T);
+    }
+    RawWaker::new(data, waker_vtable::<T>())
+}
+
+unsafe fn wake_arc_raw<T: Wake>(data: *const ()) {
+    // Safety: `data` was created from an `Arc::as_ptr` in function `waker_ref`.
+    let arc: Arc<T> = unsafe { Arc::from_raw(data as *const T) };
+    Wake::wake(arc);
+}
+
+// used by `waker_ref`
+unsafe fn wake_by_ref_arc_raw<T: Wake>(data: *const ()) {
+    // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop
+    // Safety: `data` was created from an `Arc::as_ptr` in function `waker_ref`.
+    let arc = ManuallyDrop::new(unsafe { Arc::<T>::from_raw(data.cast()) });
+    Wake::wake_by_ref(&arc);
+}
+
+unsafe fn drop_arc_raw<T: Wake>(data: *const ()) {
+    // Safety: `data` was created from an `Arc::as_ptr` in function `waker_ref`.
+    drop(unsafe { Arc::<T>::from_raw(data.cast()) });
+}

data/rust-vendor/tokio/src/util/wake_list.rs

@@ -0,0 +1,83 @@
+use core::mem::MaybeUninit;
+use core::ptr;
+use std::task::Waker;
+
+const NUM_WAKERS: usize = 32;
+
+/// A list of wakers to be woken.
+///
+/// # Invariants
+///
+/// The first `curr` elements of `inner` are initialized.
+pub(crate) struct WakeList {
+    inner: [MaybeUninit<Waker>; NUM_WAKERS],
+    curr: usize,
+}
+
+impl WakeList {
+    pub(crate) fn new() -> Self {
+        const UNINIT_WAKER: MaybeUninit<Waker> = MaybeUninit::uninit();
+
+        Self {
+            inner: [UNINIT_WAKER; NUM_WAKERS],
+            curr: 0,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn can_push(&self) -> bool {
+        self.curr < NUM_WAKERS
+    }
+
+    pub(crate) fn push(&mut self, val: Waker) {
+        debug_assert!(self.can_push());
+
+        self.inner[self.curr] = MaybeUninit::new(val);
+        self.curr += 1;
+    }
+
+    pub(crate) fn wake_all(&mut self) {
+        struct DropGuard {
+            start: *mut Waker,
+            end: *mut Waker,
+        }
+
+        impl Drop for DropGuard {
+            fn drop(&mut self) {
+                // SAFETY: Both pointers are part of the same object, with `start <= end`.
+                let len = unsafe { self.end.offset_from(self.start) } as usize;
+                let slice = ptr::slice_from_raw_parts_mut(self.start, len);
+                // SAFETY: All elements in `start..len` are initialized, so we can drop them.
+                unsafe { ptr::drop_in_place(slice) };
+            }
+        }
+
+        debug_assert!(self.curr <= NUM_WAKERS);
+
+        let mut guard = {
+            let start = self.inner.as_mut_ptr().cast::<Waker>();
+            // SAFETY: The resulting pointer is in bounds or one after the length of the same object.
+            let end = unsafe { start.add(self.curr) };
+            // Transfer ownership of the wakers in `inner` to `DropGuard`.
+            self.curr = 0;
+            DropGuard { start, end }
+        };
+        while !ptr::eq(guard.start, guard.end) {
+            // SAFETY: `start` is always initialized if `start != end`.
+            let waker = unsafe { ptr::read(guard.start) };
+            // SAFETY: The resulting pointer is in bounds or one after the length of the same object.
+            guard.start = unsafe { guard.start.add(1) };
+            // If this panics, then `guard` will clean up the remaining wakers.
+            waker.wake();
+        }
+    }
+}
+
+impl Drop for WakeList {
+    fn drop(&mut self) {
+        let slice =
+            ptr::slice_from_raw_parts_mut(self.inner.as_mut_ptr().cast::<Waker>(), self.curr);
+        // SAFETY: The first `curr` elements are initialized, so we can drop them.
+        unsafe { ptr::drop_in_place(slice) };
+    }
+}

data/rust-vendor/tokio/tests/_require_full.rs

@@ -0,0 +1,8 @@
+#[cfg(not(any(feature = "full", target_family = "wasm")))]
+compile_error!("run main Tokio tests with `--features full`");
+
+// CI sets `--cfg tokio_no_parking_lot` when trying to run tests with
+// `parking_lot` disabled. This check prevents "silent failure" if `parking_lot`
+// accidentally gets enabled.
+#[cfg(all(tokio_no_parking_lot, feature = "parking_lot"))]
+compile_error!("parking_lot feature enabled when it should not be");