| Age | Commit message (Collapse) | Author | Lines |
|---|
|
|
|
const fn: Improve wording
fixes #59611
This might need discussion. Feel free to close this PR if we don't need to fix.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Unregress using scalar unions in constants.
fixes https://github.com/rust-lang/rust/issues/59126
r? @RalfJung
I also made a bunch of these invariants panic instead of report an error.
|
|
|
|
|
|
|
|
|
|
|
|
Don't promote function calls to nonpromotable things
fixes https://github.com/rust-lang/rust/issues/58767 and fixes https://github.com/rust-lang/rust/issues/58634
r? @eddyb
should we additionally check the function call return type? It might be a promotable function (or any `const fn` inside a `const fn`), but its return type might contain interior mutability.
|
|
Make `Unique::as_ptr`, `NonNull::dangling` and `NonNull::cast` const
|
|
|
|
```
error[E0004]: non-exhaustive patterns: type `X` is non-empty
--> file.rs:9:11
|
1 | / enum X {
2 | | A,
| | - variant not covered
3 | | B,
| | - variant not covered
4 | | C,
| | - variant not covered
5 | | }
| |_- `X` defined here
...
9 | match x {
| ^
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `B` and `C` not covered
--> file.rs:11:11
|
1 | / enum X {
2 | | A,
3 | | B,
4 | | C,
| | - not covered
5 | | }
| |_- `X` defined here
...
11 | match x {
| ^ patterns `C` not covered
```
When a match expression doesn't have patterns covering every variant,
point at the enum's definition span. On a best effort basis, point at the
variant(s) that are missing. This does not handle the case when the missing
pattern is due to a field's enum variants:
```
enum E1 {
A,
B,
C,
}
enum E2 {
A(E1),
B,
}
fn foo() {
match E2::A(E1::A) {
E2::A(E1::B) => {}
E2::B => {}
}
//~^ ERROR `E2::A(E1::A)` and `E2::A(E1::C)` not handled
}
```
Unify look between match with no arms and match with some missing patterns.
Fix #37518.
|
|
Make `Unique::as_ptr` const without feature attribute as it's unstable
Make `NonNull::dangling` and `NonNull::cast` const with `feature = "const_ptr_nonnull"`
|
|
|
|
Add expected/provided byte alignments to validation error message
Fixes #58617
|
|
|
|
|
|
|
|
|
|
AFAICT, we do not have the same const-eval issues that we used to when
rust-lang/rust#23926 was filed. (Probably because of the switch to
miri for const-evaluation.)
|
|
r=oli-obk
compile-pass test for #53606
fixes #53606
|
|
|
|
|
|
|
|
|
|
Fix evaluating trivial drop glue in constants
```rust
struct A;
impl Drop for A {
fn drop(&mut self) {}
}
const FOO: Option<A> = None;
const BAR: () = (FOO, ()).1;
```
was erroring with
```
error: any use of this value will cause an error
--> src/lib.rs:9:1
|
9 | const BAR: () = (FOO, ()).1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^-^
| |
| calling non-const function `std::ptr::real_drop_in_place::<(std::option::Option<A>, ())> - shim(Some((std::option::Option<A>, ())))`
|
= note: #[deny(const_err)] on by default
error: aborting due to previous error
```
before this PR. According to godbolt this last compiled successfully in 1.27
|
|
|
|
|
|
Rollup of 9 pull requests
Successful merges:
- #57537 (Small perf improvement for fmt)
- #57552 (Default images)
- #57604 (Make `str` indexing generic on `SliceIndex`.)
- #57667 (Fix memory leak in P::filter_map)
- #57677 (const_eval: Predetermine the layout of all locals when pushing a stack frame)
- #57791 (Add regression test for #54582)
- #57798 (Corrected spelling inconsistency)
- #57809 (Add powerpc64-unknown-freebsd)
- #57813 (fix validation range printing when encountering undef)
Failed merges:
r? @ghost
|
|
fix validation range printing when encountering undef
|
|
Remove unnecessary dummy span checks
The emitter already verifies wether a given span note or span label
can be emitted to the output. If it can't, because it is a dummy
span, it will be either elided for labels or emitted as an unspanned
note/help when applicable.
|
|
|
|
|
|
The emitter already verifies wether a given span note or span label
can be emitted to the output. If it can't, because it is a dummy
span, it will be either elided for labels or emitted as an unspanned
note/help when applicable.
|
|
|
|
Stabilize `let` bindings and destructuring in constants and const fn
r? @Centril
This PR stabilizes the following features in constants and `const` functions:
* irrefutable destructuring patterns (e.g. `const fn foo((x, y): (u8, u8)) { ... }`)
* `let` bindings (e.g. `let x = 1;`)
* mutable `let` bindings (e.g. `let mut x = 1;`)
* assignment (e.g. `x = y`) and assignment operator (e.g. `x += y`) expressions, even where the assignment target is a projection (e.g. a struct field or index operation like `x[3] = 42`)
* expression statements (e.g. `3;`)
This PR does explicitly *not* stabilize:
* mutable references (i.e. `&mut T`)
* dereferencing mutable references
* refutable patterns (e.g. `Some(x)`)
* operations on `UnsafeCell` types (as that would need raw pointers and mutable references and such, not because it is explicitly forbidden. We can't explicitly forbid it as such values are OK as long as they aren't mutated.)
* We are not stabilizing `let` bindings in constants that use `&&` and `||` short circuiting operations. These are treated as `&` and `|` inside `const` and `static` items right now. If we stopped treating them as `&` and `|` after stabilizing `let` bindings, we'd break code like `let mut x = false; false && { x = true; false };`. So to use `let` bindings in constants you need to change `&&` and `||` to `&` and `|` respectively.
|
|
|
|
Const-stabilize `const_int_ops` + `const_ip`
r? @oli-obk
## Note for relnotes: This PR includes https://github.com/rust-lang/rust/pull/57105.
I've added T-lang since this affects intrinsics and the operational semantics of Rust's `const fn` fragment.
## Stable APIs proposed for constification
+ `const_int_ops`:
+ `count_ones`
+ `count_zeros`
+ `leading_zeros`
+ `trailing_zeros`
+ `swap_bytes`
+ `from_be`
+ `from_le`
+ `to_be`
+ `to_le`
+ `const_ip`
+ `Ipv4Addr::new`
## Unstable APIs constified
+ `const_int_conversion`:
+ `reverse_bits`
|
|
|
|
|
|
|
