Mehdi Akiki
Rust Failure Atlas / failure families

Runtime, memory, and library APIs

The code compiles, but a library contract, state transition, ordering, ownership rule, or unsafe invariant is incomplete.

This page lists all 225 records in this family. 223 of them have a failing and a repaired fixture, and 54 are keyed to a compiler error code. Use the Atlas search to filter by mechanism, first check, or evidence.

Below the application layer

These cases in this family depend on the linker, a native toolchain, the target, a Cargo profile, the test harness, or the runtime. They are also featured on the Atlas front page.

Complete symptom directory

Case identifiers and anchors are stable. Records whose page is not published yet are listed without a link. Records marked “no fixture yet” link to an article and have no executable fixture.

  1. RFA-019 — Adding or changing `PhantomData` unexpectedly changes variance, `Send`, `Sync`, or drop checking.No fixture yet
  2. RFA-020 — Pointer code works as an integer-address round trip until optimization or a stricter tool changes the result.No fixture yet
  3. RFA-034 — A mutex remains usable even though the operation protected by it returned an error or an async task failed.
  4. RFA-038 — A release-only Rust crash disappears when a log statement, assertion, or unrelated local variable is added.
  5. RFA-047 — A self-referential Rust value works in place but its internal pointer becomes invalid after the value moves.
  6. RFA-048 — A raw pointer into a Vec becomes invalid after an unrelated push, reserve, or extension of the vector.
  7. RFA-049 — Dropping a very large recursive Rust structure overflows the thread stack even though construction and traversal succeeded.
  8. RFA-075 — A generic helper using `transmute<T, U>` fails with E0512 even though callers intend to choose equal-sized types.
  9. RFA-076 — Casting a `*const str` directly to `usize` fails with E0606 because the raw string-slice pointer is wide.
  10. RFA-079 — A Rust union containing `String` fails with E0740 because a union field may not run automatic drop glue.
  11. RFA-080 — Rust 2024 code denies a raw-pointer dereference inside `unsafe fn` until the operation receives its own unsafe block.
  12. RFA-091 — A global `static Cell<u64>` fails E0277 because `Cell` cannot be shared between threads safely.
  13. RFA-092 — Calling a mutating `Vec` method through `Arc<Vec<T>>` fails E0596 because Arc does not provide mutable access.
  14. RFA-093 — `Arc<RefCell<T>>` still cannot enter `thread::spawn` because RefCell is not Sync despite the atomic reference count.
  15. RFA-111 — A receiver consumes every current message but times out instead of observing disconnection because one Sender remains alive.
  16. RFA-112 — try_send reports Full on sync_channel(0) even though the channel stores no buffered messages.
  17. RFA-113 — A second OnceLock::set returns Err with the rejected value, and an unconditional unwrap turns it into a panic.
  18. RFA-114 — RefCell::borrow_mut panics because an earlier RefMut guard remains alive when another exclusive borrow begins.
  19. RFA-115 — Arc::try_unwrap returns Err after work appears complete because another strong Arc owner is still alive.
  20. RFA-123 — A wrapper with an integer and PhantomData<*const T> cannot cross thread::spawn because the phantom raw pointer affects Send.
  21. RFA-131 — Writing into BufWriter succeeds because bytes enter memory, then dropping the writer silently discards an error raised while flushing them downstream.
  22. RFA-132 — A HashMap contains a key, but looking it up by the key's new visible value returns None after interior mutability changed its hash and equality state.
  23. RFA-133 — A BinaryHeap item becomes the largest value through interior mutation, but peek still returns the old root because the heap was never reorganized.
  24. RFA-134 — A Once initializer panics, and a later ordinary call_once intended as a retry panics immediately because the Once remains poisoned.
  25. RFA-135 — A Mutex remains locked after its guard is passed to mem::forget, so a later try_lock reports that the lock would block indefinitely.
  26. RFA-138 — catch_unwind rejects a closure that mutably borrows local state because &mut T is not considered safe to cross the unwind boundary automatically.
  27. RFA-142 — Arc::get_mut returns None even though only one strong Arc remains, because an apparently harmless Weak observer still points to the allocation.
  28. RFA-143 — Upgrading the Weak pointer inside Arc::new_cyclic's construction closure returns None instead of the Arc currently being created.
  29. RFA-144 — A mutex acquired only in a while let condition remains locked inside the loop body, so an immediate try_lock reports WouldBlock.
  30. RFA-145 — A process aborts while unwinding because a Drop implementation panics during cleanup of the original panic, so catch boundaries never receive control.
  31. RFA-146 — Forgetting a Vec::Drain iterator leaves the source vector missing more elements than the requested range instead of preserving the undrained tail.
  32. RFA-147 — Calling next again after map_while returns None unexpectedly produces another item, even though downstream code treated the first None as permanent exhaustion.
  33. RFA-148 — Mutex::get_mut returns PoisonError despite having an exclusive mutable reference to the mutex and no possibility of another thread holding the lock.
  34. RFA-149 — Pin::get_mut rejects a pinned value containing PhantomPinned even though the caller only wants an ordinary mutable reference to update one field.
  35. RFA-152 — Binding a MutexGuard with let underscore either fails the let_underscore_lock lint or silently ends the critical section before the following work.
  36. RFA-153 — Read::read_to_string leaves an old prefix in the destination, producing concatenated text where the caller expected the new input to replace existing contents.
  37. RFA-154 — HashMap::insert updates the value for an equal key but get_key_value still returns the original stored key rather than the replacement key supplied to insert.
  38. RFA-155 — String::truncate panics for an index smaller than the string length because that byte index falls inside a multi-byte UTF-8 character.
  39. RFA-156 — HashSet::replace stores a new value equal to an existing member, while code expected the set to retain its original canonical representative.
  40. RFA-157 — Option::take_if returns None but mutations made inside its predicate remain in the Some value left behind.
  41. RFA-158 — Peekable::peek triggers an observable pull from the underlying iterator even though it does not consume the item from the Peekable adapter.
  42. RFA-159 — After collecting a prefix with take_while on an iterator borrowed by_ref, the first item that failed the predicate is missing from the remaining iterator.
  43. RFA-160 — An atomic load using Ordering::Release fails the invalid_atomic_ordering lint even though Release is a valid Ordering variant.
  44. RFA-161 — compare_exchange rejects Ordering::Release for its failure ordering while accepting release semantics in the success ordering.
  45. RFA-162 — A Weak pointer stops upgrading after Arc::make_mut even though no strong Arc was explicitly dropped by the application.
  46. RFA-163 — A worker continues to completion after its JoinHandle is dropped, while the caller expected dropping the handle to cancel the thread.
  47. RFA-164 — One successful Write::write call stores only a prefix of the input and silently leaves the remaining bytes unwritten.
  48. RFA-166 — Vec::dedup_by passes a later element as the first closure argument and its earlier neighbour as the second, reversing code that named them left and right.
  49. RFA-167 — Writing through Cursor::new over a populated Vec replaces its first bytes instead of appending after the existing contents.
  50. RFA-168 — RwLock::is_poisoned remains false after a panic while a read guard is held, contrary to code expecting every guard panic to poison the lock.
  51. RFA-169 — thread::scope panics after its closure returns because a scoped child panicked and its JoinHandle was left for automatic joining.
  52. RFA-172 — str::find returns index 2 for the visually second character in éclair because the returned position counts UTF-8 bytes rather than Unicode scalar values.
  53. RFA-174 — OnceLock::get returns None while another thread is inside get_or_init, although the value will become initialized moments later.
  54. RFA-175 — Arc::try_unwrap succeeds while a Weak pointer exists, then that observer can no longer upgrade after the final strong owner is consumed.
  55. RFA-176 — A binary search over sorted duplicate values returns a later matching index although application code expected the first occurrence.
  56. RFA-181 — VecDeque::as_slices returns live elements across two slices after front removals and back insertions wrap its ring storage.
  57. RFA-182 — Arc::into_inner returns None for one clone and then Some for the final clone, although code assumed all cloned attempts would fail.
  58. RFA-183 — HashMap::get_disjoint_mut panics when the query array contains the same key twice instead of returning one Some and one None.
  59. RFA-184 — BTreeMap::range panics for a dynamic range whose start is greater than its end instead of yielding an empty iterator.
  60. RFA-185 — Duration::new with 1 second and 1.5 billion nanoseconds produces 2.5 seconds rather than preserving the supplied fields.
  61. RFA-187 — After one item is taken from Vec::extract_if and the iterator is dropped, later matching values remain in the original vector.
  62. RFA-188 — Receiver::try_iter returns None after draining current messages although a live sender publishes another message immediately afterward.
  63. RFA-189 — HashMap Entry::or_insert constructs and immediately drops an expensive default although the requested key is already occupied.
  64. RFA-190 — slice::sort_by_key invokes an expensive key function many more times than the number of elements being sorted.
  65. RFA-191 — After zip ends because its second general iterator is exhausted, the first iterator has unexpectedly lost one unpaired item.
  66. RFA-192 — Reading one character from String::drain and dropping the iterator removes every character in the selected range.
  67. RFA-193 — BinaryHeap::into_sorted_vec returns the smallest value first although repeatedly calling pop on the same max-heap returns the largest first.
  68. RFA-197 — After one removed value is read from Vec::splice, dropping the iterator removes the whole selected range and inserts every replacement.
  69. RFA-198 — BTreeMap::append replaces an existing configuration value with the conflicting value from the other map.
  70. RFA-201 — BTreeMap::split_off places the requested boundary key in the returned map although the caller expected that key to stay in the original map.
  71. RFA-204 — Vec::resize creates several new elements with the same logical identity although the caller expected a fresh identifier for every slot.
  72. RFA-205 — Option::insert replaces an already configured value with a fallback although the caller intended to insert only when the Option was None.
  73. RFA-206 — Collecting an iterator into Result<Vec<_>, _> returns the first error while later input records remain completely unvisited.
  74. RFA-207 — HashMap::drain removes every entry but the empty map still reports a large capacity and keeps its previous allocation.
  75. RFA-208 — After select_nth_unstable finds the correct nth value, the surrounding slice is still not globally sorted.
  76. RFA-209 — Iterator::max_by_key chooses the last candidate among equal maximum scores although the caller expected the earliest winner.
  77. RFA-210 — Flattening an iterator of Result values produces only successful values and silently removes every error from the output.
  78. RFA-214 — Duration::as_millis returns one for a duration of 1,999 microseconds although timeout code expected the value to round up to two.
  79. RFA-218 — Iterating over chunks_exact(2) for a five-element slice visits only four values and silently leaves the fifth outside the iterator.
  80. RFA-220 — Iterator::position reports one for a value at source index two after one element was consumed.
  81. RFA-223 — u8::MAX.checked_shl(1) returns Some(254) although the mathematical result does not fit in u8.
  82. RFA-225 — Removing the item at index two with swap_remove_front changes the order of the first two remaining queue items.
  83. RFA-226 — Sender::send returns Ok, but the receiver is dropped with the queued job still unprocessed.
  84. RFA-227 — Sorting zero and negative zero with total_cmp reverses their bit-pattern order even though ordinary equality considers them equal.
  85. RFA-228 — A constructor with side effects runs even though false.then_some returns None.
  86. RFA-230 — After nth(2) returns the third value, the next iterator call returns the fourth value rather than the second.
  87. RFA-231 — Rotating a three-item VecDeque left by four panics instead of wrapping around by one position.
  88. RFA-233 — Constructing Duration from negative floating-point seconds panics instead of returning a value or Result.
  89. RFA-234 — Three threads all leave a Barrier, but only one BarrierWaitResult reports is_leader as true.
  90. RFA-235 — JoinHandle::is_finished becomes true for a worker that panicked, so completion is mistaken for success.
  91. RFA-236 — Two unpark calls made before two park calls release the first park, but the second park still waits.
  92. RFA-241 — copy_from_slice panics when copying a two-byte source into a three-byte destination instead of copying the available prefix.
  93. RFA-246 — Vec::truncate with length three leaves a one-element vector unchanged instead of extending it to three elements.
  94. RFA-250 — Calling slice::chunks with a size of zero panics instead of yielding no chunks or one empty chunk.
  95. RFA-252 — Iterator::step_by panics for a dynamic step of zero instead of repeating the current element or returning an empty iterator.
  96. RFA-255 — A value passed to Box::leak never runs its Drop implementation even after the returned reference is no longer used.
  97. RFA-260 — Collecting an iterator of Result returns the first Err while later items remain unvisited in the borrowed iterator.
  98. RFA-261 — Iterator::all returns false at the first rejected element and leaves later elements unvisited through by_ref.
  99. RFA-265 — Iterator::is_sorted returns false after the first descending pair and leaves later items unvisited through by_ref.
  100. RFA-266 — Receiver::recv returns a queued message after the final Sender is dropped and reports disconnection only after draining it.
  101. RFA-269 — After Vec::append, all source elements appear in the destination and the source vector has length zero.
  102. RFA-270 — Vec::split_off at index two leaves only indices below two in the original vector and puts the boundary element in the returned vector.
  103. RFA-284 — Calling Cow::to_mut on borrowed text changes an owned clone while the original borrowed source remains unchanged.
  104. RFA-285 — HashSet::take with an equal query returns the concrete stored value, including payload fields ignored by equality, and removes it from the set.
  105. RFA-293 — catch_unwind returns Err for a panic, but a configured panic hook has already observed and reported that panic.
  106. RFA-294 — RefCell::swap panics when the same cell is supplied as both receiver and argument instead of treating self-swap as a no-op.
  107. RFA-295 — Writing a second resource-owning value into initialized MaybeUninit storage causes only the second value to be dropped later.
  108. RFA-297 — Vec::swap_remove deletes a middle value but moves the final value into its index, changing the remaining sequence order.
  109. RFA-300 — Vec::with_capacity for a zero-sized element reports usize::MAX instead of the requested capacity, despite making no enormous allocation.
  110. RFA-301 — Wrapping NonNull in UnsafeCell preserves the direct inner size but makes an enclosing Option larger on a 64-bit target.
  111. RFA-302 — A caught panic payload is resumed and caught again, but the configured panic hook does not observe a second panic event.
  112. RFA-312 — Iterating a BinaryHeap starts with its maximum but does not produce every later value in descending priority order.
  113. RFA-313 — Forgetting a mutably dereferenced BinaryHeap PeekMut leaves a valid heap but can reduce its visible length by more than one element.
  114. RFA-314 — Reducing a Vec length with unsafe set_len causes destructor counters to omit the resource-owning values hidden in the old tail.
  115. RFA-315 — A HashSet intersection item carries ignored metadata from the other set even though intersection was invoked on self.
  116. RFA-327 — Once::is_completed reports false after an initializer definitely ran but panicked before successful completion.
  117. RFA-328 — A later RwLock reader receives PoisonError after a writer changes protected state and panics while its guard remains alive.
  118. RFA-329 — Consuming a uniquely owned Mutex with into_inner still returns PoisonError after an earlier guarded worker panic.
  119. RFA-332 — Every later force of a LazyLock panics after its one-shot initialization closure panics on the first access.
  120. RFA-339 — A sorted VecDeque successfully finds an item with binary search even though its ring allocation is split into two slices.
  121. RFA-344 — recv_timeout returns Disconnected immediately instead of waiting until the requested receive deadline.
  122. RFA-350 — After mem::take returns the previous value, the destination contains a valid custom default state rather than the domain-empty state the caller expected.
  123. RFA-351 — After the greatest BinaryHeap item is lowered through PeekMut, another item becomes the root as soon as the guard leaves scope.
  124. RFA-356 — Builder::spawn panics for a configured thread name containing an interior NUL instead of returning an io::Error.
  125. RFA-357 — A second OnceLock::set returns Err containing the second owned value while the first value remains stored.
  126. RFA-359 — Receiver::try_iter yields None while a channel is empty and then yields Some after its still-connected sender publishes.
  127. RFA-360 — After one value is taken from BinaryHeap::drain and the iterator is dropped, the heap contains zero elements rather than the two unvisited values.
  128. RFA-362 — A BTreeMap retain predicate observes keys 1, 2, 3 even though the entries were inserted in the order 3, 1, 2.
  129. RFA-390 — An overlapping slice copy produces memmove-style output instead of repeatedly copying values already overwritten earlier in the loop.
  130. RFA-391 — Vec::extend_from_within appends one clone of the selected range and does not recursively include elements appended during the operation.
  131. RFA-394 — Drop counters remain zero immediately after mem::replace even though one value was removed and another installed.
  132. RFA-396 — sort_by_cached_key calls an observable key function three times for three elements instead of repeating it during comparisons.
  133. RFA-403 — Calling drop on a shared reference leaves the referenced value alive and its destructor counter unchanged.
  134. RFA-404 — Arc::unwrap_or_clone increments the inner Clone counter when another strong Arc owner still exists.
  135. RFA-405 — Vec::reserve(9) reallocates a length-two vector with capacity ten although nine looks smaller than the current capacity.
  136. RFA-409 — A Vec with capacity thirty-two returns from an into_boxed_slice and into_vec round trip with capacity equal to its three-element length.
  137. RFA-410 — Two slices begin at the same byte address but ptr::eq returns false because their lengths differ.
  138. RFA-411 — size_of_val on a three-element u32 slice reports twelve bytes rather than one element or the size of the fat reference.
  139. RFA-412 — needs_drop reports false for ManuallyDrop<Tracked> even though Tracked has an observable Drop implementation.
  140. RFA-413 — NonNull::<u64>::dangling produces an aligned nonzero address instead of a null sentinel.
  141. RFA-423 — A struct named Handle<T> stores only a numeric ID, so rustc reports E0392 because T does not participate in the type's fields.
  142. RFA-428 — Deriving Copy for a record containing Vec<u8> fails with E0204 because bitwise implicit duplication would create two owners of one allocation.
  143. RFA-429 — Casting *const u8 directly to *const [u8] fails with E0607 because the source address contains no slice-length metadata.
  144. RFA-433 — Writing unsafe impl Ready for Job fails with E0199 because Ready is a safe trait and places no unchecked safety obligation on implementors.
  145. RFA-434 — Implementing unsafe trait TrustedBytes with an ordinary impl fails with E0200 because the implementation has not explicitly acknowledged the trait's unchecked invariants.
  146. RFA-439 — Writing impl Sized for Record fails with E0322 because Sized is a compiler-known trait whose implementations follow type layout automatically.
  147. RFA-507 — Defining Chain::Link with another Chain stored directly fails with E0072 because computing the enum's layout recurses without a finite size.
  148. RFA-508 — Declaring struct View with text: &str fails with E0106 because a stored reference needs a named lifetime relationship on the containing type.
  149. RFA-513 — Implementing Drop for &mut Resource fails with E0120 because Drop may be implemented only for local structs, enums, and unions.
  150. RFA-517 — Calling a self-by-value Consume method through Box<dyn Consume> fails with E0161 because the erased dyn value has no compile-time-known inline size to move.
  151. RFA-523 — A dyn Transfer trait object deriving both source and target lifetime bounds fails with E0227 because no unique object lifetime can be inferred.
  152. RFA-524 — Writing impl View<'a> without impl<'a> fails with E0261 because the lifetime name is not declared in the impl scope.
  153. RFA-525 — Declaring fn borrow<'static> fails with E0262 because 'static is a reserved built-in lifetime and cannot be introduced as a generic parameter.
  154. RFA-531 — A Snapshot field using <T as Project<'a>>::Output fails with E0309 because the applicable implementation requires T: 'a but the struct does not promise it.
  155. RFA-532 — A function with elided input and output lifetimes calls a helper requiring T: 'a and fails with E0311 because its generic T has no matching outlives promise.
  156. RFA-541 — A closure captures events mutably while an earlier reference to events[0] is still used, producing E0500 because both borrows would be live together.
  157. RFA-542 — Using events directly after a closure has captured it for mutation fails with E0501 because the closure is called later and still owns the unique borrow.
  158. RFA-543 — Reading count directly after creating &mut count fails with E0503 because the mutable reference is used later and therefore keeps exclusive access active.
  159. RFA-544 — Moving payload into archive fails with E0505 because event_id borrows its string storage and is used after the ownership transfer.
  160. RFA-545 — Assigning a new String to endpoint fails with E0506 because selected still borrows the old string and is read after the replacement.
  161. RFA-546 — Binding workers[0] as an owned String fails with E0508 because indexing provides a place inside the still-whole array and String is not Copy.
  162. RFA-548 — Creating reserve and commit closures that both capture total for mutation fails with E0524 because both closure values would hold unique access at once.
  163. RFA-554 — Defining an associated type as &'outer Handler<'inner> fails with E0491 because Handler may carry data valid for less time than the outer reference.
  164. RFA-555 — Borrowing a const AtomicUsize into a static reference fails with E0492 because const use denotes a value expression rather than one stable shared storage location.
  165. RFA-567 — The type for<'a> fn() -> &'a str fails with E0581 because callers could choose any return lifetime while no input connects that choice to valid storage.
  166. RFA-568 — Requiring F: for<'a> Fn(u32) -> Option<&'a str> fails with E0582 because 'a appears only in the associated Output binding and no callback input constrains it.
  167. RFA-574 — Saving response.as_str() outside the block that owns response fails with E0597 because the String is dropped before the saved view is used.
  168. RFA-582 — Writing *attempts fails with E0614 because attempts is already a u32 value rather than a reference or a type implementing Deref.
  169. RFA-587 — Casting an array reference to bare [usize] fails with E0620 because a slice type has no compile-time size and cannot exist as a local by-value result.
  170. RFA-588 — A function promises to return only left's lifetime but may return right, so rustc emits E0621 and asks for an explicit matching lifetime.
  171. RFA-589 — A conversion promises an output borrow under an unrelated lifetime and fails with E0623 because input is not known to outlive output.
  172. RFA-593 — Declaring fn choose<'_> fails with E0637 because '_ is reserved for an inferred anonymous lifetime, not a bindable generic parameter name.
  173. RFA-608 — In edition 2021, an impl Trait return hides Cell<&'data u32> without capturing 'data in its bounds, so rustc emits E0700.
  174. RFA-612 — Returning a mutable borrow from a consumed Guard fails with E0713 because Guard::drop still needs exclusive access to that same data.
  175. RFA-613 — Borrowing a temporary String through identity and saving its str view fails with E0716 because the owner is dropped after the let statement.
  176. RFA-615 — A recursive iterator function returning impl Iterator fails with E0720 because its hidden concrete chain type contains itself indefinitely.
  177. RFA-625 — Taking a raw address of the temporary integer 2 fails with E0745 because the temporary has no storage lifetime suitable for the pointer.
  178. RFA-636 — Using &Store as a trait object in edition 2024 fails with E0782 because trait-object types require the explicit dyn keyword.
  179. RFA-642 — Trying to instantiate identity with an explicit static lifetime fails with E0794 because its input-linked lifetime is late-bound for every call.
  180. RFA-644 — Putting the function item main inside an opaque return use bound fails with E0799 because precise capture lists accept generic parameters rather than arbitrary names.
  181. RFA-645 — Writing use<T> on a function with no T parameter fails with E0800 because the opaque return capture list references no generic in scope.
  182. RFA-647 — Implementing DataAccess<&f64> for a borrowed container fails with E0803 because the trait argument and method return do not say how their lifetimes relate to self.
  183. RFA-648 — Casting *const dyn Any to *const (dyn Any + Send) fails with E0804 because a pointer cast cannot prove the erased concrete type implements the added auto trait.
  184. RFA-650 — Creating and immediately dropping Vec::drain still removes the range, contrary to the assumption that only yielded elements are deleted.
  185. RFA-651 — Calling split_off(4) on a three-element vector panics because the split index must be no greater than the current length.
  186. RFA-652 — Truncating éclair at byte index one panics because that index falls inside the two-byte UTF-8 encoding of é.
  187. RFA-653 — Inserting running for an existing job key returns Some(queued), not None, because HashMap::insert replaces and yields the old value.
  188. RFA-654 — Inserting key 2 before key 1 still iterates as 1 then 2 because BTreeMap traversal is ordered by Ord rather than insertion time.
  189. RFA-657 — After Arc::make_mut changes one of two strong owners, the Arcs no longer point to the same allocation because the inner Vec was cloned.
  190. RFA-658 — A Weak handle cannot upgrade after the final strong Arc is dropped because the allocation no longer contains a live value.
  191. RFA-659 — Unwrapping a mutex lock panics after another thread panicked while holding the guard because the mutex is marked poisoned.
  192. RFA-660 — Growing a vector with Vec::resize creates several Arc values, but changing one element appears to change every element.
  193. RFA-661 — Removing one vector element with swap_remove leaves the right elements but unexpectedly changes their order.
  194. RFA-662 — Calling dedup leaves repeated values in a vector when equal values are separated by another element.
  195. RFA-663 — copy_from_slice panics when copying a short source into a larger destination buffer even though enough capacity is available.
  196. RFA-664 — Rotating a three-element slice left by four panics instead of wrapping the distance around automatically.
  197. RFA-665 — chunks_exact_mut updates every full chunk but leaves the final mutable elements unchanged unless its remainder is recovered.
  198. RFA-666 — Calling entry(key).or_insert(fallback) leaves the old map value in place when the key already exists.
  199. RFA-667 — After appending one vector into another through a mutable reference, the source vector unexpectedly has length zero.
  200. RFA-668 — Calling make_contiguous on a wrapped VecDeque rearranges its backing storage but iteration still returns exactly the previous order.
  201. RFA-669 — Converting a max-heap with into_sorted_vec returns ascending values while repeatedly popping the same values returns descending order.
  202. RFA-670 — Inserting into an Option that is already Some drops the previous resource before later code expects to recover it.
  203. RFA-672 — After mem::replace, a destructor counter has not advanced because the previous value was returned rather than dropped.
  204. RFA-673 — After mem::take returns the current state, the original place contains State::default rather than its previous generation.
  205. RFA-674 — A byte range that was valid for éclair makes replace_range panic after one ASCII character is inserted before it.
  206. RFA-675 — Calling get(0..1) on éclair returns None even though byte index one is less than the string's total byte length.
  207. RFA-678 — Subtracting five seconds from a two-second Duration panics because Duration cannot represent a negative result.
  208. RFA-679 — Calling earlier.duration_since(later) returns zero rather than the one-second magnitude expected from the two instants.
  209. RFA-680 — A second OnceLock::set returns Err with the rejected value and the cell continues to contain its first value.
  210. RFA-681 — A closure passed to the second get_or_init call never runs because the OnceLock already contains a value.
  211. RFA-682 — Dropping the original Sender does not disconnect the receiver because another Sender clone is still alive.
  212. RFA-683 — try_send on sync_channel(0) returns Full when no receiver is waiting because the channel has no buffering slot.
  213. RFA-684 — Reading an RwLock with unwrap panics after another thread panicked while holding its write guard.
  214. RFA-685 — A reader mutates an AtomicU8 behind an RwLock read guard and then panics, but the outer RwLock remains unpoisoned.
  215. RFA-686 — Four threads pass a Barrier together, but only one BarrierWaitResult reports is_leader true.
  216. RFA-687 — Atomic compare_exchange returns Err(5), not Err(4), when the expected value 4 is stale and the atomic currently contains 5.
  217. RFA-688 — After a call_once initializer panics, a later ordinary call_once panics again instead of running a replacement closure.
  218. RFA-689 — After get_or_init panics, OnceLock::get returns None and a later initializer can successfully publish a value.
  219. RFA-690 — Rc::get_mut returns None even with one strong owner because a Weak pointer to the same allocation is still alive.
  220. RFA-691 — Arc::try_unwrap returns the inner value despite a live Weak pointer because no other strong owner keeps that value alive.
  221. RFA-699 — slice::subslice_range returns None for a separate slice containing exactly the values visible inside the original slice.
  222. RFA-700 — str::substr_range returns None for equal text stored in another String instead of locating its matching byte range.
  223. RFA-703 — slice::strip_circumfix returns None even though the slice starts with the prefix and ends with the suffix.
  224. RFA-704 — After AtomicU8::from_mut_slice creates an atomic view, assigning through the original byte slice fails with E0506.
  225. RFA-715 — Converting an exhausted legacy RangeInclusive into the new std::range::RangeInclusive panics instead of producing an empty bounds value.