Mehdi Akiki
Rust Failure Atlas / failure families

Language and diagnostics

Ownership, lifetimes, traits, inference, expressions, and macros can make the reported location different from the real cause.

This page lists all 225 records in this family. 222 of them have a failing and a repaired fixture, and 205 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-001 — A procedural-macro error underlines the invocation instead of the invalid token.No fixture yet
  2. RFA-002 — A macro resolves a name in the caller or definition crate when I expected the other one.No fixture yet
  3. RFA-003 — `Iterator::map` rejects `.await`, or the obvious rewrite accidentally becomes sequential.No fixture yet
  4. RFA-050 — A Rust doctest sees different cfg values, crate structure, or imports from a normal unit or integration test.
  5. RFA-051 — Rust reports a borrow of a partially moved value after one owned field was extracted from a struct.
  6. RFA-052 — Assigning through `values[values.len() - 1]` fails because the same vector is borrowed as mutable and immutable.
  7. RFA-053 — A function returning `HashMap::get_mut` from one branch cannot insert and borrow the map again in the other branch.
  8. RFA-054 — A function cannot return `&str` created from a local `String`, even when the requested lifetime is written as `'static`.
  9. RFA-055 — Borrowing from a constructed value in one `let` statement produces E0716: temporary value dropped while borrowed.
  10. RFA-056 — The `?` operator rejects an inner error even though both the called function and its caller return `Result`.
  11. RFA-057 — Calling `.into()` produces E0283 because several destination types can be constructed from the same source type.
  12. RFA-058 — Rust says a method does not exist even though a visible trait implements that method for the receiver type.
  13. RFA-059 — A trait works as a generic bound but Rust rejects `&dyn Trait` because a method has its own type parameter.
  14. RFA-060 — A function returning `impl Iterator` rejects `if` branches that each return a valid iterator with the same item type.
  15. RFA-061 — A returned closure receives E0373 because it borrows a local value owned by the function that creates it.
  16. RFA-062 — Adding an explicit `&str` type to a closure parameter triggers E0521 because the borrowed argument escapes into an outer vector.
  17. RFA-063 — An `impl Iterator` return gets E0700 because its hidden iterator type captures an input lifetime not named in the return bounds.
  18. RFA-064 — Rust rejects `dyn Source` with E0191 because the trait's associated `Item` type was not fixed at the object boundary.
  19. RFA-065 — `Iterator::chain` produces E0271 when one iterator yields `&u8` and the next yields owned `u8` values.
  20. RFA-066 — Trait solving ends with E0275 and an enormous nested type after a recursive blanket implementation was added.
  21. RFA-067 — A concrete trait implementation conflicts with a blanket implementation even though its current where-clause is not satisfied.
  22. RFA-068 — An inherent `impl<T>` receives E0207 because the type parameter appears only inside one method body or return expression.
  23. RFA-069 — Implementing `From<LocalWrapper<T>> for T` fails with E0210 even though the wrapper in the trait arguments is local.
  24. RFA-070 — Moving an owned field out of a consumed struct fails with E0509 only after the struct receives a `Drop` implementation.
  25. RFA-071 — A closure that changes a captured variable is rejected because the receiving API requires `Fn` instead of `FnMut`.
  26. RFA-072 — A closure passed as `FnMut` cannot move and consume one captured String even when the API currently calls it only once.
  27. RFA-073 — A directly recursive async function fails with E0733 because its generated future would need to contain itself.
  28. RFA-074 — Using `.await` inside an ordinary function produces E0728 even when the awaited expression is itself an async block.
  29. RFA-077 — A constant expression fails the build with E0080 when evaluation reaches an operation that would panic at runtime.
  30. RFA-078 — A constant initializer receives E0015 because it calls an ordinary function that happens to return a compile-time-friendly value.
  31. RFA-107 — A proc-macro library is rejected because it exports a public helper that is not one of the three procedural macro entry forms.
  32. RFA-108 — A procedural macro fails when applied inside the same proc-macro crate that defines it.
  33. RFA-120 — Assigning an incoming string reference through a mutable slot fails because the incoming lifetime may be shorter than the slot promises.
  34. RFA-121 — An identity-looking closure is not general enough for a for<'a> Fn(&'a str) -> &'a str bound.
  35. RFA-122 — A lending-style generic associated type is rejected because its declaration lacks the required where Self: 'a bound.
  36. RFA-126 — A Drop implementation requires T: Display, but the generic structure itself permits every T and rustc rejects the mismatch with E0367.
  37. RFA-127 — A function tries to return a boxed trait object containing a borrowed value, but rustc says that the borrow must outlive 'static.
  38. RFA-128 — Deriving Default for a generic marker type prevents Marker<NoDefault> from using default even though PhantomData<T> itself is always defaultable.
  39. RFA-129 — Deriving Clone for a generic wrapper around Arc<T> makes Shared<NoClone>::clone unavailable although cloning an Arc does not clone its T.
  40. RFA-130 — Two helper functions both return impl Iterator<Item = u8>, but selecting between their results fails because the opaque return types are distinct.
  41. RFA-136 — Deriving Copy for a small token fails with E0184 after the type receives a Drop implementation, even though all of its fields are copyable.
  42. RFA-137 — mem::take cannot move a non-Default Session out through a mutable reference, although the caller has a valid replacement value available.
  43. RFA-139 — A generic helper calling TypeId::of::<T>() fails with E0310 because its unconstrained T may contain a non-static borrowed lifetime.
  44. RFA-140 — A macro captures the literal 3 as an expr and forwards it, but a second macro cannot match that forwarded fragment with its literal (3) arm.
  45. RFA-150 — A macro_rules expansion fails because one metavariable repeats twice while another repeats once, although both lists matched the macro input successfully.
  46. RFA-170 — An exported macro using $crate resolves its helper in the defining crate but still fails with E0603 because that helper is private to downstream callers.
  47. RFA-245 — Result::map_or calls an expensive or state-changing default expression even when the Result is Ok and the default is discarded.
  48. RFA-253 — Option::xor discards both present operands and returns None when code expected it to prefer the first Some value.
  49. RFA-254 — Result::and runs the expression producing its second Result even when the first Result is already Err.
  50. RFA-296 — Calling type_id directly on Box<dyn Any> does not match TypeId::of::<u32>() even though the contained value is a u32.
  51. RFA-349 — A return expression inside a closure ends the closure call while the lexically enclosing function continues execution.
  52. RFA-368 — Writing dyn Read + Write produces E0225 because both Read and Write are non-auto traits in one trait-object bound list.
  53. RFA-369 — A trait containing async fn compiles for static dispatch but produces E0038 when code tries to create &dyn HealthCheck.
  54. RFA-370 — Adding an associated constant to a trait makes `&dyn Trait` fail even though every implementation supplies the constant.
  55. RFA-371 — A method returning Self prevents creating a trait object although another receiver method could be dispatched safely.
  56. RFA-372 — An explicitly numbered enum variant collides with an earlier implicit zero and rustc reports E0081.
  57. RFA-373 — A repr(u8) enum variant after an explicit value of 255 fails with E0370 instead of wrapping to zero.
  58. RFA-375 — A generic type alias that expands to u64 fails with E0091 because its type parameter is absent from the aliased type.
  59. RFA-376 — A local variable annotation using impl Iterator fails with E0562 even though the same impl Trait syntax works in a function return type.
  60. RFA-380 — A trait containing only an ordinary receiver method cannot become dyn Trait because Sized is declared as a supertrait.
  61. RFA-381 — A trait associated function with no self receiver prevents creating a trait object even though dynamic code never calls that function.
  62. RFA-382 — A trait method returning impl Iterator works generically but makes the trait unavailable as dyn Trait.
  63. RFA-383 — Using Self as a type argument of a supertrait makes an otherwise empty trait fail dyn compatibility.
  64. RFA-384 — A trait method receiving self as Rc<Box<Self>> makes the trait not dyn compatible although Rc<Self> is supported.
  65. RFA-385 — Method-call syntax reports E0034 when two implemented traits contribute the same method name and receiver signature.
  66. RFA-386 — Calling a receiver-free function as Trait::create reports E0790 even when only one implementation currently exists.
  67. RFA-387 — Self::Item is ambiguous inside a trait inheriting two supertraits that both define an Item associated type.
  68. RFA-400 — Implementing Drop only for one concrete instantiation of a generic wrapper fails with E0366 even though no other Drop implementation exists.
  69. RFA-418 — A let-else statement whose else block evaluates to zero fails E0308 because the else branch does not diverge.
  70. RFA-419 — Breaking with value seven from while true fails E0571 even though the loop condition never becomes false.
  71. RFA-420 — A trait method accepts every T, but one implementation adds T: Copy and fails with E0276 instead of becoming a specialised implementation.
  72. RFA-421 — A trait declares a u16 input but its implementation accepts i16, producing E0053 even though the implementation could cast the value internally.
  73. RFA-422 — A trait declares flush without a self receiver, but an implementation adds &self and fails with E0185 rather than receiving an instance automatically.
  74. RFA-424 — An argument written as impl Contains<impl Token> fails with E0666 because one anonymous impl Trait is nested inside another.
  75. RFA-426 — A function returning dyn Label fails with E0746 because the trait object's concrete value has no statically known size or inline return layout.
  76. RFA-430 — Buffer<T, const N: T> fails with E0770 because the type of const parameter N refers to the preceding generic type T.
  77. RFA-431 — A trait method uses an impl Iterator parameter while its implementation spells the parameter as a named generic I, causing E0643 despite similar bounds.
  78. RFA-432 — Calling saturating_add on a binding initialised as 2 fails with E0689 because several integer types provide that method and no context selects one.
  79. RFA-435 — A function declared inside outer<T> uses T in its parameter and fails with E0401 because nested items do not inherit outer generic parameters.
  80. RFA-436 — Putting #[derive(Clone)] on a trait's associated type declaration fails with E0774 because derive generates implementations for concrete data declarations, not type requirements.
  81. RFA-437 — Inside trait Convert<T>, declaring fn convert<T> introduces a second T and fails with E0403 because associated-item generics cannot shadow containing generics.
  82. RFA-440 — A match over State handles Ready but not Failed, so rustc emits E0004 even when today's caller happens to construct only Ready.
  83. RFA-441 — Writing let Some(number) = value fails with E0005 because value can be None and a plain let binding has no failure branch.
  84. RFA-442 — Matching Event::Move(x) fails with E0023 because the tuple variant was declared with two fields and the pattern supplies only one position.
  85. RFA-443 — A Point pattern writes x: horizontal and x: vertical, producing E0025 because the same source field is selected twice.
  86. RFA-444 — A Point pattern uses { x, z } hoping z renames y, but rustc emits E0026 because shorthand asks for a real field literally named z.
  87. RFA-445 — Destructuring Record { id } fails with E0027 because payload is neither matched nor covered by an explicit rest pattern.
  88. RFA-446 — The match arm 10..=5 fails with E0030 because an inclusive range pattern must have a lower bound no greater than its upper bound.
  89. RFA-447 — Writing Event::new() on the left side of a match arm fails with E0164 because a function call is an expression, not a tuple variant or tuple-struct pattern.
  90. RFA-448 — Matching an f32 with [left, right] fails with E0529 because bracket patterns destructure arrays and slices, not arbitrary values or numeric representations.
  91. RFA-449 — Using LIMIT as a match arm pattern fails with E0530 when LIMIT names a static, because it cannot become either a permitted static-value pattern or a new shadowing binding.
  92. RFA-450 — Combining Message::Data(value) and Message::Empty with | fails with E0408 because value does not exist for every alternative sharing the arm body.
  93. RFA-451 — An or-pattern binds value with ref in one tuple alternative and by value in the other, producing E0409 because the shared body would receive inconsistent types and ownership.
  94. RFA-452 — The tuple pattern (value, value) fails with E0416 because a single pattern cannot introduce the same local identifier for two different positions.
  95. RFA-453 — Destructuring with Packet(value) fails with E0531 when Packet is not a tuple struct or tuple variant visible in the current scope.
  96. RFA-454 — Matching State::Failed as if it were a unit variant fails with E0532 because Failed was declared with a String payload.
  97. RFA-455 — Using Parser::default_code without parentheses as a match pattern fails with E0533 because the path names an associated function item, not a unit value or structural constant.
  98. RFA-456 — Destructuring a four-element array with [first, second] fails with E0527 because that fixed pattern describes exactly two elements.
  99. RFA-457 — The pattern [first, second, third, ..] fails with E0528 against a two-element array because it requires at least three positions.
  100. RFA-458 — A bare Get pattern triggers E0170 under the bindings_with_variant_name lint because it creates a catch-all binding instead of matching Method::Get.
  101. RFA-460 — Writing impl Encode for Packet fails with E0404 when Encode resolves to a struct, because the position after impl expects a trait contract.
  102. RFA-461 — Writing impl Encodable for Packet fails with E0405 when no trait named Encodable is visible in the module containing the implementation.
  103. RFA-462 — Defining save inside impl Store for Memory fails with E0407 because Store declares only load and the extra method is not one of that trait's associated items.
  104. RFA-463 — A free function returning Self fails with E0411 because no enclosing trait, implementation, or type definition establishes what the Self type means.
  105. RFA-464 — Declaring fn merge(value: u8, value: u8) fails with E0415 because both parameters try to introduce the same local binding in one function body.
  106. RFA-465 — Constructing Packet { id: 7 } fails with E0422 when no struct, struct variant, or union type named Packet resolves in the current scope.
  107. RFA-466 — Calling Config() fails with E0423 because Config is a named-field struct type, not a function, tuple-struct constructor, or tuple variant in the value namespace.
  108. RFA-467 — An associated function current() tries to read self.0 and fails with E0424 because its parameter list contains no self receiver value.
  109. RFA-468 — Writing break 'outer fails with E0426 when no enclosing loop or labelled block declares the 'outer label in scope.
  110. RFA-469 — Declaring two functions named decode in one module fails with E0428 because both create the same value-namespace name and Rust does not overload free functions by signature.
  111. RFA-470 — Importing first::run and second::run into one module fails with E0252 because both functions claim the same local value-namespace name.
  112. RFA-471 — After extern crate core, importing helpers::core fails with E0254 because the current module already uses core as an external-crate name.
  113. RFA-472 — Importing helpers::run into a module that also declares fn run fails with E0255 because both functions define the same local value-namespace name.
  114. RFA-474 — After extern crate core, declaring struct core fails with E0260 because the local item conflicts with the external crate root already named core.
  115. RFA-475 — Writing pub use connect as public_connect fails with E0364 when connect itself is private and therefore cannot support the promised external visibility.
  116. RFA-476 — Writing pub use engine as public_engine fails with E0365 when the engine module is private to the crate and cannot itself become an externally reachable module alias.
  117. RFA-477 — Using ..current while constructing Schedule::Daily fails with E0436 because functional record update accepts a struct base, not a struct-like enum variant value.
  118. RFA-478 — Declaring pub Ready inside a public enum fails with E0449 because enum variants always share the visibility of their containing enum.
  119. RFA-479 — Constructing model::Config with its private secret field fails with E0451 even though Config and its name field are public.
  120. RFA-480 — A nested fn inner reads outer's offset and fails with E0434 because function items do not capture values from the dynamic enclosing stack frame.
  121. RFA-481 — Using a local let binding as [u8; width] fails with E0435 because fixed-array length is part of the type and must be evaluable at compile time.
  122. RFA-482 — Defining type Error inside impl Decode for Packet fails with E0437 when the Decode trait never declares an associated type named Error.
  123. RFA-483 — Defining const CAPACITY inside impl Window for Buffer fails with E0438 when Window does not declare that associated constant.
  124. RFA-484 — The projection <D as Decoder>::Error fails with E0576 because Decoder declares Output but no associated type named Error.
  125. RFA-485 — A Source method returning &Self::Error fails with E0220 because the trait declares Item but never declares an associated type named Error.
  126. RFA-486 — Writing dyn BoxCar<Color = C> fails with E0222 because both Vehicle and Container supertraits declare an associated type named Color.
  127. RFA-487 — Using Source::Item as a standalone type fails with E0223 because the trait declaration does not choose one concrete Item without an implementing type.
  128. RFA-488 — The alias dyn Read + 'a + 'b fails with E0226 because one trait object type cannot carry two separate explicit object lifetime bounds.
  129. RFA-489 — Writing <I as Source<Item = u8>>::Item fails with E0229 because associated item equality constraints are not allowed inside that qualified projection path.
  130. RFA-490 — Implementing Reporter for HealthCheck with an empty impl fails with E0046 because the required report method has no implementation or default.
  131. RFA-491 — Implementing generic Convert::convert with a concrete u32 parameter fails with E0049 because the impl method removes the trait method's type parameter.
  132. RFA-492 — Implementing Window::contains with only &self fails with E0050 because the trait declaration also requires a value parameter.
  133. RFA-493 — Implementing Reset::reset without its &mut self receiver fails with E0186 because the trait declares an instance method but the impl declares an associated function.
  134. RFA-494 — Implementing Choose::choose without the declared 'long: 'short relationship fails with E0195 because the impl accepts a different set of lifetime relationships.
  135. RFA-495 — Defining Encode::encode twice inside one trait impl fails with E0201 because both method bodies claim the same associated-item identity.
  136. RFA-496 — Declaring T with ?Sized twice fails with E0203 because Rust permits only one relaxation of the implicit Sized bound.
  137. RFA-497 — Implementing the Limits constant MAX_RETRIES as fn MAX_RETRIES fails with E0324 because a method cannot fill an associated-constant slot.
  138. RFA-498 — Implementing the Limits constant MAX_RETRIES with type MAX_RETRIES = u8 fails with E0325 because an associated type cannot fill an associated-constant slot.
  139. RFA-499 — Implementing FeatureFlag::ENABLED as u8 fails with E0326 because the trait requires that associated constant to have type bool.
  140. RFA-500 — Casting 1_u8 with as bool fails with E0054 because Rust does not define an integer-to-boolean cast.
  141. RFA-501 — Calling schedule with only the task argument fails with E0061 because the function signature also requires a retry count.
  142. RFA-502 — Constructing Limits with two retries fields fails with E0062 because one struct expression cannot provide two values for the same field.
  143. RFA-503 — Constructing Limits with retries but no timeout_ms fails with E0063 because the named-field struct value would be incomplete.
  144. RFA-504 — Writing 12 += 1 fails with E0067 because the left operand is a literal value rather than a mutable place that can store the result.
  145. RFA-505 — Assigning RETRIES = 4 fails with E0070 because RETRIES resolves to a const value, not a mutable storage location.
  146. RFA-506 — Writing Counter { value: 4 } fails with E0071 when Counter is only an alias for u64 rather than a named-field struct type.
  147. RFA-509 — Using Envelope<u8, u16> fails with E0107 because Envelope declares one type parameter but the use supplies two generic arguments.
  148. RFA-510 — Writing u64<u8> fails with E0109 because the builtin integer type declares no generic parameters that could receive u8.
  149. RFA-511 — Defining an inherent impl on Vec<u8> fails with E0116 because Vec is owned by the standard library crate rather than the current crate.
  150. RFA-512 — Writing impl<T> T fails with E0118 because an unconstrained type parameter is not a nominal struct, enum, union, or trait-object self type.
  151. RFA-515 — Declaring fn main<T>() fails with E0131 because the executable entry point cannot require a caller to choose generic arguments.
  152. RFA-516 — Matching on P::ACTIVE fails with E0158 because a constant pattern cannot depend on a generic policy parameter during generic type checking.
  153. RFA-518 — Writing &'a dyn Send + Sync fails with an ambiguous-plus diagnostic because it is unclear whether Sync belongs inside the referenced trait object type.
  154. RFA-520 — Writing unsafe impl Counter fails with E0197 because an inherent impl is not an unsafe-trait implementation.
  155. RFA-522 — Writing Vec(&str) in a type position fails with E0214 because ordinary generic type arguments use angle brackets.
  156. RFA-526 — Using break inside a closure with no loop in that closure fails with E0267 because the closure is a separate control-flow body.
  157. RFA-527 — Using break directly inside a function fails with E0268 because there is no enclosing loop or labelled breakable block to receive control.
  158. RFA-528 — Binding Vec::new without later element use fails with E0282 because inference has no evidence for the vector's element type.
  159. RFA-529 — Adding u64 and u32.into() fails with E0284 because both Into's output and Add's right-hand type remain generic enough to admit multiple candidates.
  160. RFA-530 — Declaring an inherent method with self: &Scheduler inside impl Cache fails with E0307 because the receiver does not lead back to Cache.
  161. RFA-533 — A where predicate written as for<'a> &'a T: for<'b> Relates<'a, 'b> fails with E0316 because it nests one higher-ranked lifetime quantifier inside another.
  162. RFA-534 — Credits supports the + operator through Add but total += Credits(3) fails with E0368 because AddAssign is a separate trait obligation.
  163. RFA-535 — Comparing two Version values with > fails with E0369 because the struct has fields but no PartialOrd implementation defining how whole values are ordered.
  164. RFA-536 — Implementing Observable for dyn Service fails with E0371 because Service declares Observable as a supertrait and every Service trait object already carries that obligation.
  165. RFA-537 — Returning address after assigning it only inside the production branch fails with E0381 because the false path reaches the use with no initialized value.
  166. RFA-538 — Assigning a second value to retries fails with E0384 because let bindings are immutable unless their declaration explicitly opts into mutation.
  167. RFA-539 — Declaring Reads: Writes and Writes: Reads fails with E0391 because computing either trait's supertrait obligations recursively requires the other.
  168. RFA-540 — Writing impl u64 with a retry-budget method fails with E0390 because a crate cannot add inherent items to a primitive type it does not define.
  169. RFA-547 — Assigning state = None inside a guard while matching state fails with E0510 because the guard would change the value whose arm selection is still in progress.
  170. RFA-549 — Passing a closure that drops its captured String to run_twice fails with E0525 because consuming the capture permits only one call, while the function requires Fn.
  171. RFA-550 — Writing &dyn Convert when Convert<T = Self> fails with E0393 because erasing Self also removes the concrete value needed by that default.
  172. RFA-551 — A public Decode implementation exposes private InternalRecord as its associated Record type and fails with E0446 because downstream callers could name the public projection but not its result.
  173. RFA-552 — Writing allow(non_snake_case = "legacy protocol name") fails with E0452 because a lint name is an identifier, not a key accepting a string value.
  174. RFA-553 — An item-level allow(non_snake_case) under crate-level forbid(non_snake_case) fails with E0453 because forbid deliberately prevents weaker inner overrides.
  175. RFA-556 — Selecting tuple element .1 in a static initializer fails with E0493 because the unselected Guard must be dropped during const evaluation and Guard has a custom runtime destructor.
  176. RFA-557 — A method declares its own 'a inside impl<'a> View<'a> and fails with E0496 because the inner lifetime name would shadow the stored-data lifetime.
  177. RFA-559 — Constructing Limits with timeout_ms fails with E0560 because the resolved Limits definition declares only retries.
  178. RFA-560 — A function pointer alias written as fn(mut value: u32) fails with E0561 because mut is a binding pattern, while a function type describes only the callable signature.
  179. RFA-562 — Declaring a function return type as State::Ready fails with E0573 because Ready is a variant value in the State type, not its own type.
  180. RFA-563 — Using protocol { version: 1 } fails with E0574 because protocol resolves to a module, while record construction requires a struct, struct-like variant, or union.
  181. RFA-564 — Writing pub(in crate::Boundary) where Boundary is an enum fails with E0577 because a restricted visibility scope must resolve to an ancestor module.
  182. RFA-565 — The match pattern 0..0 fails with E0579 because an exclusive range includes its lower bound but excludes the identical upper bound, leaving no possible value.
  183. RFA-566 — Declaring main(port: u16) fails with E0580 because the runtime entry point cannot receive arbitrary typed parameters from the operating system.
  184. RFA-570 — Using an unlabeled break inside a while condition fails with E0590 even though the condition is lexically inside that loop.
  185. RFA-572 — Two inherent impl blocks define Client::connect and fail with E0592 even when their source locations or bodies differ.
  186. RFA-573 — Passing a zero-argument closure where F: Fn(u32) -> u32 is required fails with E0593 because the callable contract supplies one argument.
  187. RFA-575 — Applying ! to Enabled fails with E0600 because a boolean-looking wrapper does not automatically implement the Not operator.
  188. RFA-577 — Casting a u32 code point directly to char fails with E0604 because not every u32 is a valid Unicode scalar value.
  189. RFA-578 — Casting u8 to Vec<u8> with as fails with E0605 because as handles specified primitive casts and coercions, not allocation or collection construction.
  190. RFA-579 — Writing point[0] fails with E0608 because a struct does not become positionally indexable merely because it stores multiple fields.
  191. RFA-580 — Reading metrics.errors fails with E0609 because the resolved Metrics struct defines requests but no errors field.
  192. RFA-581 — Reading timeout_ms.value fails with E0610 because u64 is a primitive numeric type and has no named fields.
  193. RFA-583 — Reading queue.pending without parentheses fails with E0615 because pending resolves to a method, not a stored field value.
  194. RFA-584 — Reading Balance.cents outside its defining module fails with E0616 because the struct is public but its representation field remains private.
  195. RFA-586 — Writing retries() fails with E0618 after a local u8 named retries shadows the intended callable name.
  196. RFA-590 — Calling Token::rotate outside its defining module fails with E0624 because the method is private even though Token and new are public.
  197. RFA-591 — A closure annotated to accept &str is passed to F: Fn(i32), producing E0631 because the caller supplies an integer.
  198. RFA-595 — Destructuring a tuple in a trait method declaration without a body fails with E0642 because patterns belong to implementations, not abstract signatures.
  199. RFA-596 — Implementing a trait's impl Iterator parameter as an explicit named I fails with E0643 because the generic parameter shapes do not match.
  200. RFA-599 — Re-exporting primary::* and fallback::* makes dispatch::run ambiguous and produces E0659 because both functions claim the same path.
  201. RFA-600 — Deriving Default for Mode fails with E0665 because rustc cannot choose between Active and Passive without an explicitly marked variant.
  202. RFA-602 — Calling sqrt on an unconstrained floating literal fails with E0689 because rustc cannot select the f32 or f64 inherent method set.
  203. RFA-606 — An unlabeled break inside a labelled block nested in a loop fails with E0695 because the block interrupts implicit loop targeting.
  204. RFA-607 — Writing continue 'decision for a labelled block fails with E0696 because a one-shot block has no next iteration.
  205. RFA-610 — Writing pub(storage) fails with E0704 because a module path restriction needs the in keyword and an allowed ancestor path.
  206. RFA-611 — Writing clipp::needless_return fails with E0710 because clipp is not a known lint tool namespace.
  207. RFA-614 — Writing dyn Iterator<Item = u32, Item = u32> fails with E0719 because the same associated type is specified twice.
  208. RFA-617 — Matching [7, ..] against [u8; N] fails with E0730 because the generic length is not one fixed pattern shape during type checking.
  209. RFA-621 — A struct default such as T = Box<Self> fails with E0735 because a type parameter default cannot refer to the type currently being defined.
  210. RFA-624 — An item inside land cannot use pub(in crate::sea) because sea is a sibling rather than an ancestor, producing E0742.
  211. RFA-627 — Supplying a type where Borrowed expects its lifetime first fails with E0747 because generic arguments must correspond to declared parameter kinds.
  212. RFA-628 — Opening a raw string with two hash marks and closing it with one fails with E0748 because the lexer cannot find the matching delimiter.
  213. RFA-630 — An inner //! comment placed after an item fails with E0753 because it can no longer attach to the enclosing module before that module's contents.
  214. RFA-632 — A closure tries to break an outer labelled loop and fails with E0767 because labels are unreachable through callable and suspension boundaries.
  215. RFA-633 — Matching tuple variant Message(String) with a named-field struct pattern fails with E0769 because construction and destructuring shapes disagree.
  216. RFA-634 — Declaring const CAPACITY: T beside generic T fails with E0770 because a const parameter's type cannot depend on another generic parameter.
  217. RFA-635 — Applying derive(Clone) to a function fails with E0774 because derive macros generate trait implementations for structs, enums, or unions.
  218. RFA-640 — Opening a block comment without a closing delimiter fails with E0758 because the lexer treats every later token as comment text.
  219. RFA-641 — Writing the binary prefix 0b with no following digits fails with E0768 because the token does not contain an integer value.
  220. RFA-643 — Writing Settings { retries: 3, .. } fails with E0797 because omitted fields need a concrete base expression to supply their values.
  221. RFA-646 — Declaring self: R where R is a method generic Deref target fails with E0801 because receiver type must have a concrete supported form.
  222. RFA-649 — Writing inline() with empty parentheses fails with E0805 because inline accepts no input as #[inline] or one recognised argument.
  223. RFA-655 — After nth(1) returns 20, next returns 30 because nth advances past one element and consumes the selected element too.
  224. RFA-656 — Collecting an iterator of Result values stops after visiting the first Err, so later elements and their mapping work are not evaluated.
  225. RFA-671 — A Result remains Err after inspect_err logs the error, so a later success assertion or question-mark return still fails.