| Age | Commit message (Collapse) | Author | Lines |
|
Remove reverted feature from relnotes
|
|
|
|
Beta next
|
|
|
|
This reverts commit ac73335f2f5421c914fa3900567696cc6dc73d8d.
|
|
[beta] Fix optimization regressions for operations on [x; n]-initialized arr…
|
|
|
|
[beta] Add changelog for 1.12
|
|
|
|
Backport #36496
|
|
Bump to 1.12.0-beta.5
|
|
|
|
Conflicts:
src/librustc_trans/adt.rs
|
|
Beta backports
|
|
|
|
|
|
This is done by creating a little space on the stack. Hokey, but it's
the simplest fix I can see.
|
|
Fixes #36401
|
|
[beta] Update rust-installer. Fixes #35840
|
|
|
|
Fix build error
|
|
|
|
Bump to beta.4
|
|
|
|
Beta backports
|
|
Go back on half the specialization, the part that changed the Zip
struct's fields themselves depending on the types of the iterators.
This means that the Zip iterator will always carry two usize fields,
which are unused. If a whole for loop using a .zip() iterator is
inlined, these are simply removed and have no effect.
The same improvement for Zip of for example slice iterators remain, and
they still optimize well. However, like when the specialization of zip
was merged, the compiler is still very sensistive to the exact context.
For example this code only autovectorizes if the function is used, not
if the code in zip_sum_i32 is inserted inline it was called:
```
fn zip_sum_i32(xs: &[i32], ys: &[i32]) -> i32 {
let mut s = 0;
for (&x, &y) in xs.iter().zip(ys) {
s += x * y;
}
s
}
fn zipdot_i32_default_zip(b: &mut test::Bencher)
{
let xs = vec![1; 1024];
let ys = vec![1; 1024];
b.iter(|| {
zip_sum_i32(&xs, &ys)
})
}
```
Include a test that checks that Zip<T, U> is covariant w.r.t. T and U.
|
|
|
|
Fixes #36474
|
|
Beta backports
|
|
|
|
We were treating an associated type as unsized even when the concrete
instantiation was actually sized. Fix is to normalize before checking
if it is sized.
|
|
Bump beta to .3
|
|
|
|
Backport PRs to beta
|
|
|
|
This makes the critical calculation easier to understand.
|
|
The memrchr fallback did not compute the offset correctly. It was
intentioned to land on usize-aligned addresses but did not.
This was suspected to resulted in a crash on ARMv7 platform!
This bug affected non-linux platforms.
I think like this, if we have a slice with pointer `ptr` and length
`len`, we want to find the last usize-aligned offset in the slice.
The correct computation should be:
For example if ptr = 1 and len = 6, and size_of::<usize>() is 4:
[ x x x x x x ]
1 2 3 4 5 6
^-- last aligned address at offset 3 from the start.
The last aligned address is ptr + len - (ptr + len) % usize_size.
Compute offset from the start as:
offset = len - (ptr + len) % usize_size = 6 - (1 + 6) % 4 = 6 - 3 = 3.
I believe the function's return value was always correct previously, if
the platform supported unaligned addresses.
|
|
|
|
This fixes #35849, a regression introduced by the typeck refactoring
around TyNever/!.
|
|
Backport PRs to beta
|
|
|
|
|
|
Fixes #35737
|
|
|
|
Closes #35721
|
|
Stabilized
* `Cell::as_ptr`
* `RefCell::as_ptr`
* `IpAddr::is_{unspecified,loopback,multicast}`
* `Ipv6Addr::octets`
* `LinkedList::contains`
* `VecDeque::contains`
* `ExitStatusExt::from_raw` - both on Unix and Windows
* `Receiver::recv_timeout`
* `RecvTimeoutError`
* `BinaryHeap::peek_mut`
* `PeekMut`
* `iter::Product`
* `iter::Sum`
* `OccupiedEntry::remove_entry`
* `VacantEntry::into_key`
Deprecated
* `Cell::as_unsafe_cell`
* `RefCell::as_unsafe_cell`
* `OccupiedEntry::remove_pair`
Closes #27708
cc #27709
Closes #32313
Closes #32630
Closes #32713
Closes #34029
Closes #34392
Closes #34285
Closes #34529
|
|
Bump boostrap compilers
|
|
|
|
Fix incorrect unused import warnings on `cfg_attr`ed `path` attributes
Fixes #35584.
r? @eddyb
|
|
Implement the `!` type
This implements the never type (`!`) and hides it behind the feature gate `#[feature(never_type)]`. With the feature gate off, things should build as normal (although some error messages may be different). With the gate on, `!` is usable as a type and diverging type variables (ie. types that are unconstrained by anything in the code) will default to `!` instead of `()`.
|