setlocale and TextDomain::init are unsound as they access environment with no synchronization

Safe ErrorRegistry APIs can cause undefined behavior

event-listener allows !Send tags to cross thread boundaries via StackSlot

Missing Sync bound on PyCFunction::new_closure closures

Exposes reference to non-Sync data to an arbitrary thread

openssl X509NameBuilder::build returned object is not thread safe

MsQueue push/pop use the wrong orderings

Delegate functions are missing Send bound

Data race when sending and receiving after closing a oneshot channel

AtomicBucket unconditionally implements Send/Sync

MutexGuard<Cell<i32>> must not be Sync

Insufficient synchronization in Arc::get_mut

RingBuffer can create multiple mutable references and cause data races

Data race and memory safety issue in Index

Intern: Data race allowed on T

Queues allow non-Send types to be sent to other threads, allowing data races

MvccRwLock allows data races & aliasing violations

Bunch unconditionally implements Send/Sync

Queue should have a Send bound on its Send/Sync traits

convec::ConVec unconditionally implements Send/Sync

Shared can cause a data race

dces' World type can cause data races

LockWeak<T> allows to create data race to T.

AtomicBox lacks bound on its Send and Sync traits allowing data races

Slock allows sending non-Send types across thread boundaries

ShmWriter allows sending non-Send type across threads

ArcGuard's Send and Sync should have bounds on RC

SyncRef's clone() and debug() allow data races

SyncChannel can move 'T: !Send' to other threads

CopyCell lacks bounds on its Send trait allowing for data races

Send/Sync bound needed on T for Send/Sync impl of RcuCell

Cache: Send/Sync impls needs trait bounds on K

ReaderResult should be bounded by Sync

beef::Cow lacks a Sync bound on its Send trait allowing for data races

ReadTicket and WriteTicket should only be sendable when T is Send

AtomicBox implements Send/Sync for any T: Sized

Decoder<R> can carry R: !Send to other threads

Future lacks bounds on Send and Sync.

QueueSender/QueueReceiver: Send/Sync impls need T: Send

PinSlab and Unordered<T, S> need bounds on their Send/Sync traits

Singleton lacks bounds on Send and Sync.

Demuxer can carry non-Send types across thread boundaries

hashconsing's HConsed lacks Send/Sync bound for its Send/Sync trait.

may_queue's Queue lacks Send/Sync bound for its Send/Sync trait.

ButtplugFutureStateShared allows data race to (!Send|!Sync) objects

Soundness issue: Input can be misused to create data race to an object

Queues allow non-Send types to be sent to other threads, allowing data races

AtomicOption should have Send + Sync bound on its type argument.

LateStatic has incorrect Sync bound

conquer-once's OnceCell lacks Send bound for its Sync trait.

ImageChunkMut needs bounds on its Send and Sync traits

Aovec lacks bound on its Send and Sync traits allowing data races

TreeFocus lacks bounds on its Send and Sync traits

Soundness issue with base::Error

UsbContext trait did not require implementers to be Send and Sync.

Unsound: can make ARefss contain a !Send, !Sync object.

Send/Sync bound needed on V in impl Send/Sync for ARCache<K, V>

Thex allows data races of non-Send types across threads

TryMutex allows sending non-Send type across threads

MPMCConsumer/Producer allows sending non-Send type across threads

Some lock_api lock guard objects can cause data races

GenericMutexGuard allows data races of non-Sync types across threads

Improper Sync implementation on FuturesUnordered in futures-utils can cause data corruption

MutexGuard::map can cause a data race in safe code

Multiple security issues including data race, buffer overflow, and uninitialized memory drop

Unsafe Send implementation in Atom allows data races