Commit Graph

253575 Commits

Author SHA1 Message Date
Esteban Küber
386236f289 Detect borrow error involving sub-slices and suggest split_at_mut
```
error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/suggest-split-at-mut.rs:13:18
   |
LL |     let a = &mut foo[..2];
   |                  --- first mutable borrow occurs here
LL |     let b = &mut foo[2..];
   |                  ^^^ second mutable borrow occurs here
LL |     a[0] = 5;
   |     ---- first borrow later used here
   |
   = help: use `.split_at_mut(position)` or similar method to obtain two mutable non-overlapping sub-slices
```

Address most of #58792.

For follow up work, we should emit a structured suggestion for cases where we can identify the exact `let (a, b) = foo.split_at_mut(2);` call that is needed.
2024-04-25 16:55:32 +00:00
Michael Goulet
cc606174a6 Don't ICE when codegen_select returns ambiguity in new solver 2024-04-25 11:49:12 -04:00
bors
9e6c4fddda Auto merge of #123531 - compiler-errors:closure-wf, r=oli-obk
Enforce closure args + return type are WF

I found this out when investigating https://github.com/rust-lang/rust/issues/123461#issuecomment-2040894359. Turns out we don't register WF obligations for closure args and return types, leading to the ICE.

~~I think this is a useful thing to check for, but I'd like to check what the fallout is.~~ crater is complete.

~~Worst case, I think we should enforce this across an edition boundary (and possibly eventually migrate this for all editions) -- this should be super easy to do, since this is a check in HIR wfcheck, so it can be made edition dependent.~~ I believe the regressions are manageable enough to not necessitate edition-specific behavior.

Fixes #123461
2024-04-25 15:05:51 +00:00
Michael Goulet
870ed4bfa2 Add test 2024-04-25 10:51:54 -04:00
Michael Goulet
b2fea557f3 Check closure args and returns are WF 2024-04-25 10:03:17 -04:00
Michael Goulet
487cdeb039 Format stash message correctly 2024-04-25 10:03:17 -04:00
bors
6a9758d4f3 Auto merge of #124058 - TechVest:master, r=fmease
Fix some typos in comments
2024-04-25 13:02:08 +00:00
bors
1c84675e1f Auto merge of #124368 - RalfJung:miri, r=RalfJung
Miri subtree update

r? `@ghost`
2024-04-25 10:59:13 +00:00
Ralf Jung
9f7194b5eb update lockfile 2024-04-25 12:28:45 +02:00
bors
d93f9ae3ee Auto merge of #3514 - RalfJung:hyperfine, r=RalfJung
CI: run benches with hyperfine rather than bash

The hyperfine installation is cached so this should not cost a lot of CI time.

This is step 1/2 to getting rid of the BASH variable hack.
2024-04-25 09:16:32 +00:00
Ralf Jung
505e4dd7ba CI: run benches with hyperfine rather than bash 2024-04-25 11:14:22 +02:00
bors
31e6e8c6c5 Auto merge of #119650 - chenyukang:yukang-fix-118596-ref-mut, r=wesleywiser
Suggest ref mut for pattern matching assignment

Fixes #118596
2024-04-25 08:52:19 +00:00
bors
97132949f7 Auto merge of #3501 - RalfJung:tls-many-seeds, r=RalfJung
add a test for the TLS memory leak

This is a regression test for https://github.com/rust-lang/rust/issues/123583.
2024-04-25 08:14:58 +00:00
Ralf Jung
247e82cb83 run many-seeds tests at least a few times on all tier 1 targets 2024-04-25 09:53:34 +02:00
Ralf Jung
ea9cff254f add a test for the TLS memory leak 2024-04-25 09:51:15 +02:00
Ralf Jung
f38dba69b1 weak memory outdated loads: show where the load was from 2024-04-25 09:51:15 +02:00
klensy
21e97a67ab tests: remove few ignore-stage2
beta was branched long ago, so can be removed
2024-04-25 10:48:11 +03:00
bors
e22a73c6d0 Auto merge of #3512 - RalfJung:miri-script-build, r=RalfJung
make miri-script a workspace root

This is needed to make miri-script build on stable (as is done by the `./miri` script) when the parent package uses unstable cargo features.
2024-04-25 07:20:16 +00:00
bors
9d7a47fe31 Auto merge of #3513 - rust-lang:rustup-2024-04-25, r=RalfJung
Automatic Rustup
2024-04-25 06:48:37 +00:00
bors
865808b33b Auto merge of #124360 - matthiaskrgr:rollup-k6bffhd, r=matthiaskrgr
Rollup of 3 pull requests

Successful merges:

 - #124257 (Rewrite the `no-input-file.stderr` test in Rust and support diff)
 - #124324 (Minor AST cleanups)
 - #124327 (CI: implement job skipping in Python matrix calculation)

r? `@ghost`
`@rustbot` modify labels: rollup
2024-04-25 06:35:26 +00:00
bors
c69c79d42a Auto merge of #3505 - RalfJung:ci, r=RalfJung
CI: don't run cron-fail-notify when the job just got canceled

Doesn't seem right to prepare a PR in that case
2024-04-25 06:16:47 +00:00
The Miri Cronjob Bot
258e5043a1 fmt 2024-04-25 05:05:41 +00:00
The Miri Cronjob Bot
ff6fc75781 Merge from rustc 2024-04-25 05:04:32 +00:00
The Miri Cronjob Bot
bed7caf206 Preparing for merge from rustc 2024-04-25 04:57:07 +00:00
bors
284f94f9c0 Auto merge of #121298 - nikic:writable, r=cuviper
Set writable and dead_on_unwind attributes for sret arguments

Set the `writable` and `dead_on_unwind` attributes for `sret` arguments. This allows call slot optimization to remove more memcpy's.

See https://llvm.org/docs/LangRef.html#parameter-attributes for the specification of these attributes. In short, the statement we're making here is that:

 * The return slot is writable.
 * The return slot will not be read if the function unwinds.

Fixes https://github.com/rust-lang/rust/issues/90595.
2024-04-25 04:31:56 +00:00
Matthias Krüger
036bf570ad
Rollup merge of #124327 - Kobzol:ci-skip-jobs, r=pietroalbini
CI: implement job skipping in Python matrix calculation

This removes the `step` YAML anchor and the corresponding bash script.

Best reviewed commit-by-commit.

r? ```@pietroalbini```
2024-04-25 06:31:04 +02:00
Matthias Krüger
fc6070cd8e
Rollup merge of #124324 - nnethercote:minor-ast-cleanups, r=estebank
Minor AST cleanups

r? ``@estebank``
2024-04-25 06:31:04 +02:00
Matthias Krüger
a2d6b1b2d6
Rollup merge of #124257 - JoverZhang:rmake-diff, r=jieyouxu
Rewrite the `no-input-file.stderr` test in Rust and support diff

Rewrite the `no-input-file.stderr` test from #121876.
Use the `similar` lib to replace the `diff` command.
2024-04-25 06:31:03 +02:00
TechVest
45df09b7de Fix some typos in comments
Signed-off-by: TechVest <techdashen@qq.com>
2024-04-25 10:47:24 +08:00
Nikita Popov
976267b514 Add needs-unwind to codegen test
When compiled with -C panic=abort we'd generate an extra
panic_cannot_unwind shim in the variant calling C-unwind.
2024-04-25 11:44:32 +09:00
Nikita Popov
137775dd63 Fix incorrect CHECK-LABEL 2024-04-25 11:43:47 +09:00
Nikita Popov
3695af697e Set writable and dead_on_unwind attributes for sret arguments 2024-04-25 11:43:47 +09:00
Jover Zhang
f3530cf003 Rewrite no-input-file.stderr test in Rust and support diff 2024-04-25 09:10:10 +08:00
bors
cb3752d20e Auto merge of #124136 - estebank:clone-o-rama-2, r=nnethercote
Provide more context and suggestions in borrowck errors involving closures

Start pointing to where bindings where declared when they are captured in closures:

```
error[E0597]: `x` does not live long enough
  --> $DIR/suggest-return-closure.rs:23:9
   |
LL |     let x = String::new();
   |         - binding `x` declared here
...
LL |     |c| {
   |     --- value captured here
LL |         x.push(c);
   |         ^ borrowed value does not live long enough
...
LL | }
   | -- borrow later used here
   | |
   | `x` dropped here while still borrowed
```

Suggest cloning in more cases involving closures:

```
error[E0507]: cannot move out of `foo` in pattern guard
  --> $DIR/issue-27282-move-ref-mut-into-guard.rs:11:19
   |
LL |             if { (|| { let mut bar = foo; bar.take() })(); false } => {},
   |                   ^^                 --- move occurs because `foo` has type `&mut Option<&i32>`, which does not implement the `Copy` trait
   |                   |
   |                   `foo` is moved here
   |
   = note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
   |
LL |             if { (|| { let mut bar = foo.clone(); bar.take() })(); false } => {},
   |                                         ++++++++
```

Mention when type parameter could be Clone

```
error[E0382]: use of moved value: `t`
  --> $DIR/use_of_moved_value_copy_suggestions.rs:7:9
   |
LL | fn duplicate_t<T>(t: T) -> (T, T) {
   |                   - move occurs because `t` has type `T`, which does not implement the `Copy` trait
...
LL |     (t, t)
   |      -  ^ value used here after move
   |      |
   |      value moved here
   |
help: if `T` implemented `Clone`, you could clone the value
  --> $DIR/use_of_moved_value_copy_suggestions.rs:4:16
   |
LL | fn duplicate_t<T>(t: T) -> (T, T) {
   |                ^ consider constraining this type parameter with `Clone`
...
LL |     (t, t)
   |      - you could clone this value
help: consider restricting type parameter `T`
   |
LL | fn duplicate_t<T: Copy>(t: T) -> (T, T) {
   |                 ++++++
```

The `help` is new. On ADTs, we also extend the output with span labels:

```
error[E0507]: cannot move out of static item `FOO`
  --> $DIR/issue-17718-static-move.rs:6:14
   |
LL |     let _a = FOO;
   |              ^^^ move occurs because `FOO` has type `Foo`, which does not implement the `Copy` trait
   |
note: if `Foo` implemented `Clone`, you could clone the value
  --> $DIR/issue-17718-static-move.rs:1:1
   |
LL | struct Foo;
   | ^^^^^^^^^^ consider implementing `Clone` for this type
...
LL |     let _a = FOO;
   |              --- you could clone this value
help: consider borrowing here
   |
LL |     let _a = &FOO;
   |              +
```

Suggest cloning captured binding in move closure

```
error[E0507]: cannot move out of `bar`, a captured variable in an `FnMut` closure
  --> $DIR/borrowck-move-by-capture.rs:9:29
   |
LL |     let bar: Box<_> = Box::new(3);
   |         --- captured outer variable
LL |     let _g = to_fn_mut(|| {
   |                        -- captured by this `FnMut` closure
LL |         let _h = to_fn_once(move || -> isize { *bar });
   |                             ^^^^^^^^^^^^^^^^   ----
   |                             |                  |
   |                             |                  variable moved due to use in closure
   |                             |                  move occurs because `bar` has type `Box<isize>`, which does not implement the `Copy` trait
   |                             `bar` is moved here
   |
help: clone the value before moving it into the closure 1
   |
LL ~         let value = bar.clone();
LL ~         let _h = to_fn_once(move || -> isize { value });
   |
```
2024-04-25 01:00:41 +00:00
Nicholas Nethercote
2ae0765ffb Add comments about attribute tokens.
This clarifies something that has puzzled me for some time.
2024-04-25 10:14:17 +10:00
bors
dfc400e0c0 Auto merge of #124354 - matthiaskrgr:rollup-xsdnixm, r=matthiaskrgr
Rollup of 5 pull requests

Successful merges:

 - #124322 (chore: fix some typos in comments)
 - #124333 (Improve diagnostic for unknown `--print` request)
 - #124334 (Strengthen tracking issue policy with consequences)
 - #124335 (Stabilize `std::path::absolute`)
 - #124351 (fix typo in binary_heap docs)

r? `@ghost`
`@rustbot` modify labels: rollup
2024-04-24 22:29:03 +00:00
Esteban Küber
ad9a5a5f9f Suggest cloning captured binding in move closure
```
error[E0507]: cannot move out of `bar`, a captured variable in an `FnMut` closure
  --> $DIR/borrowck-move-by-capture.rs:9:29
   |
LL |     let bar: Box<_> = Box::new(3);
   |         --- captured outer variable
LL |     let _g = to_fn_mut(|| {
   |                        -- captured by this `FnMut` closure
LL |         let _h = to_fn_once(move || -> isize { *bar });
   |                             ^^^^^^^^^^^^^^^^   ----
   |                             |                  |
   |                             |                  variable moved due to use in closure
   |                             |                  move occurs because `bar` has type `Box<isize>`, which does not implement the `Copy` trait
   |                             `bar` is moved here
   |
help: clone the value before moving it into the closure
   |
LL ~         let value = bar.clone();
LL ~         let _h = to_fn_once(move || -> isize { value });
   |
```
2024-04-24 22:21:16 +00:00
Esteban Küber
d68f2a6b71 Mention when type parameter could be Clone
```
error[E0382]: use of moved value: `t`
  --> $DIR/use_of_moved_value_copy_suggestions.rs:7:9
   |
LL | fn duplicate_t<T>(t: T) -> (T, T) {
   |                   - move occurs because `t` has type `T`, which does not implement the `Copy` trait
...
LL |     (t, t)
   |      -  ^ value used here after move
   |      |
   |      value moved here
   |
help: if `T` implemented `Clone`, you could clone the value
  --> $DIR/use_of_moved_value_copy_suggestions.rs:4:16
   |
LL | fn duplicate_t<T>(t: T) -> (T, T) {
   |                ^ consider constraining this type parameter with `Clone`
...
LL |     (t, t)
   |      - you could clone this value
help: consider restricting type parameter `T`
   |
LL | fn duplicate_t<T: Copy>(t: T) -> (T, T) {
   |                 ++++++
```

The `help` is new. On ADTs, we also extend the output with span labels:

```
error[E0507]: cannot move out of static item `FOO`
  --> $DIR/issue-17718-static-move.rs:6:14
   |
LL |     let _a = FOO;
   |              ^^^ move occurs because `FOO` has type `Foo`, which does not implement the `Copy` trait
   |
note: if `Foo` implemented `Clone`, you could clone the value
  --> $DIR/issue-17718-static-move.rs:1:1
   |
LL | struct Foo;
   | ^^^^^^^^^^ consider implementing `Clone` for this type
...
LL |     let _a = FOO;
   |              --- you could clone this value
help: consider borrowing here
   |
LL |     let _a = &FOO;
   |              +
```
2024-04-24 22:21:15 +00:00
Esteban Küber
4aba2c55e6 Modify find_expr from Span to better account for closures
Start pointing to where bindings were declared when they are captured in closures:

```
error[E0597]: `x` does not live long enough
  --> $DIR/suggest-return-closure.rs:23:9
   |
LL |     let x = String::new();
   |         - binding `x` declared here
...
LL |     |c| {
   |     --- value captured here
LL |         x.push(c);
   |         ^ borrowed value does not live long enough
...
LL | }
   | -- borrow later used here
   | |
   | `x` dropped here while still borrowed
```

Suggest cloning in more cases involving closures:

```
error[E0507]: cannot move out of `foo` in pattern guard
  --> $DIR/issue-27282-move-ref-mut-into-guard.rs:11:19
   |
LL |             if { (|| { let mut bar = foo; bar.take() })(); false } => {},
   |                   ^^                 --- move occurs because `foo` has type `&mut Option<&i32>`, which does not implement the `Copy` trait
   |                   |
   |                   `foo` is moved here
   |
   = note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
   |
LL |             if { (|| { let mut bar = foo.clone(); bar.take() })(); false } => {},
   |                                         ++++++++
```
2024-04-24 22:21:13 +00:00
Matthias Krüger
62bc38dd65
Rollup merge of #124351 - Treeniks:master, r=workingjubilee
fix typo in binary_heap docs

There was an extra "the" that should not be there.
2024-04-25 00:19:56 +02:00
Matthias Krüger
ecf794bc69
Rollup merge of #124335 - ChrisDenton:stabilize-absolute, r=dtolnay
Stabilize `std::path::absolute`

FCP complete in https://github.com/rust-lang/rust/issues/92750#issuecomment-2075046985
2024-04-25 00:19:56 +02:00
Matthias Krüger
45beb36ef2
Rollup merge of #124334 - oli-obk:tracking-issue-policy, r=fmease
Strengthen tracking issue policy with consequences

As per the T-compiler MCP: https://github.com/rust-lang/compiler-team/issues/739
2024-04-25 00:19:55 +02:00
Matthias Krüger
f46b828b55
Rollup merge of #124333 - Urgau:better-bad-print, r=fmease
Improve diagnostic for unknown `--print` request

This PR improves the diagnostic when encountering a unknown `--print` request.

It also moves the run-make test to a simple UI test.
2024-04-25 00:19:55 +02:00
Matthias Krüger
177139032a
Rollup merge of #124322 - whosehang:master, r=Nilstrieb
chore: fix some typos in comments
2024-04-25 00:19:54 +02:00
Thomas Lindae
d3bbdcf26c fix typo in binary_heap docs 2024-04-24 22:59:39 +02:00
yukang
be9dbe9102 Suggest ref mut for pattern matching assignment 2024-04-25 04:54:25 +08:00
bors
ef8b9dcf23 Auto merge of #124330 - fmease:rollup-a98y7jf, r=fmease
Rollup of 6 pull requests

Successful merges:

 - #123316 (Test `#[unix_sigpipe = "inherit"]` with both `SIG_DFL` and `SIG_IGN`)
 - #123794 (More DefineOpaqueTypes::Yes)
 - #123881 (Bump Fuchsia versions)
 - #124281 (fix weak memory bug in TLS on Windows)
 - #124282 (windows fill_utf16_buf: explain the expected return value)
 - #124308 (Add diagnostic item for `std::iter::Enumerate`)

r? `@ghost`
`@rustbot` modify labels: rollup
2024-04-24 19:26:50 +00:00
bors
7bb4f0889e Auto merge of #104087 - nbdd0121:const, r=scottmcm
Stabilise inline_const

# Stabilisation Report

## Summary

This PR will stabilise `inline_const` feature in expression position. `inline_const_pat` is still unstable and will *not* be stabilised.

The feature will allow code like this:
```rust
foo(const { 1 + 1 })
```
which is roughly desugared into
```rust
struct Foo;
impl Foo {
    const FOO: i32 = 1 + 1;
}
foo(Foo::FOO)
```

This feature is from https://github.com/rust-lang/rfcs/pull/2920 and is tracked in #76001 (the tracking issue should *not* be closed as it needs to track inline const in pattern position). The initial implementation is done in #77124.

## Difference from RFC

There are two major differences (enhancements) as implemented from the RFC. First thing is that the RFC says that the type of an inline const block inferred from the content *within* it, but we currently can infer the type using the information from outside the const block as well. This is a frequently requested feature to the initial implementation (e.g. #89964). The inference is implemented in #89561 and is done by treating inline const similar to a closure and therefore share inference context with its parent body.

This allows code like:
```rust
let v: Vec<i32> = const { Vec::new() };
```

Another enhancement that differs from the RFC is that we currently allow inline consts to reference generic parameters. This is implemented in #96557.

This allows code like:
```rust
fn create_none_array<T, const N: usize>() -> [Option<T>; N] {
    [const { None::<T> }; N]
}
```

This enhancement also makes inline const usable as static asserts:

```rust
fn require_zst<T>() {
    const { assert!(std::mem::size_of::<T>() == 0) }
}
```

## Documentation

Reference: rust-lang/reference#1295

## Unresolved issues

We still have a few issues that are not resolved, but I don't think it necessarily has to block stabilisation:
* expr fragment specifier issue: #86730
* ~~`const {}` behaves similar to `async {}` but not to `{}` and `unsafe {}` (they are treated as `ExpressionWithoutBlock` rather than `ExpressionWithBlock`): https://rust-lang.zulipchat.com/#narrow/stream/213817-t-lang/topic/const.20blocks.20differ.20from.20normal.20and.20from.20unsafe.20blocks/near/290229453~~

## Tests

There are a few tests in https://github.com/rust-lang/rust/tree/master/src/test/ui/inline-const
2024-04-24 17:23:03 +00:00
Ralf Jung
8c24fe1085 make miri-script a workspace root 2024-04-24 18:05:03 +02:00
bors
246ba3b808 Auto merge of #3511 - obi1kenobi:patch-1, r=RalfJung
Upgrade to `actions/checkout@v4` in `ci.yml`.

This is a newer version of the same action. None of the uses here were particularly special (no complex features of v3 were used) so this is a straightforward as-is upgrade.
2024-04-24 15:08:09 +00:00