rust-lang/rust

The point of const_precise_live_drops is to ensure that the program can never execute a non-const drop during CTFE. The following code must therefore be rejected: #![feature(const_precise_live_drops)] struct NotConstDestruct; impl Drop for NotConstDestruct { fn drop(&mut self) {} } // Mutable borrow of a type with drop impl. pub const A1: () = { let mut x = None; let mut y = Some(NotConstDestruct); let a = &mut x; let b = &mut y; std::mem::swap(a, b); std::mem::forget(y); }; And it is: error[E0493]: destructor of `Option<NotConstDestruct>` cannot be evaluated at compile-time --> src/lib.rs:11:9 | 11 | let mut x = None; | ^^^^^ the destructor for this type cannot be evaluated in constants ... 17 | }; | - value is dropped here However, for some reason, we are then still executing this code, which obviously cannot work as the destructor is non-const: error[E0080]: calling non-const function `<NotConstDestruct as Drop>::drop` --> sr

See #157604 (comment) and the replies following it I can mentor this, if needed

For context see #t-types/nominated > #159838: Make `LazyCell<T, F>` and `LazyLock<T, F>` covaria… myself and @lcnr can mentor What I'm thinking is: we'd like an attribute like #[rustc_assert_variance(invariant/covariant/etc)] this should be placed on a lifetime or type parameter of ADTs this shouldn't cause something to have a given variance, it should check whether the lifetime/type has the given variance and throw an error if not also feel free to suggest/implement a solution that isn't an attribute

Code const A: usize = 0; struct S { a: usize, } fn main() { S { a }; } Current output error[E0425]: cannot find value `a` in this scope --> src/main.rs:8:9 | 1 | const A: usize = 0; | ------------------- similarly named constant `A` defined here ... 8 | S { a }; | ^ | help: a constant with a similar name exists | 8 - S { a }; 8 + S { A }; | For more information about this error, try `rustc --explain E0425`. Desired output error[E0425]: cannot find value `a` in this scope --> src/main.rs:8:9 | 1 | const A: usize = 0; | ------------------- similarly named constant `A` defined here ... 8 | S { a }; | ^ | help: a constant with a similar name exists | 8 - S { a }; 8 + S { a: A }; | For more information about this error, try `rustc --explain E0425`. Rationale and extra context Suggestion is incorrect, it needs to turns the initialization shorthand into a full field: expression initialization. Other cases Rust Vers

Location (URL) https://doc.rust-lang.org/std/primitive.i8.html#method.saturating_add etc. lacks the definition of overflowing / wrapping / saturating operations. Summary C++ 26's saturating_add links to wikipedia, which is a good idea. We can do things similar, maybe in a dedicated page somewhere.