unix ExitStatus: Add tracking issue to new methods

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

Replace `Ie` with `In other words`

Co-authored-by: Joshua Nelson <joshua@yottadb.com>

Replace `Ie` with `In other words`

Co-authored-by: Joshua Nelson <joshua@yottadb.com>

unix ExitStatus: Provide .continued()

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

unix ExitStatus: Provide .stopped_signal()

Necessary to handle WIFSTOPPED.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

unix ExitStatus: Provide .core_dumped

This is essential for proper reporting of child process status on Unix.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

unix ExitStatus: Provide .into_raw()

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

unix ExitStatus: Clarify docs for .signal()

We need to be clear that this never returns WSTOPSIG.  That is, if
WIFSTOPPED, the return value is None.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

unix ExitStatus: Do not treat WIFSTOPPED as WIFSIGNALED

A unix wait status can contain, at least, exit statuses, termination
signals, and stop signals.

WTERMSIG is only valid if WIFSIGNALED.

https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html

It will not be easy to experience this bug with `Command`, because
that doesn't pass WUNTRACED.  But you could make an ExitStatus
containing, say, a WIFSTOPPED, from a call to one of the libc wait
functions.

(In the WIFSTOPPED case, there is WSTOPSIG.  But a stop signal is
encoded differently to a termination signal, so WTERMSIG and WSTOPSIG
are by no means the same.)

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

Update code to account for extern ABI requirement

Lint on extern in item declaration position

Update tests for extern block linting

Introduce missing ABI lint on extern blocks

Move help link to error index

Fix -Cpasses=list and llvm version print with -vV

Auto merge of #80824 - cuviper:heap-clones, r=kennytm

Try to avoid locals when cloning into Box/Rc/Arc

For generic `T: Clone`, we can allocate an uninitialized box beforehand,
which gives the optimizer a chance to create the clone directly in the
heap. For `T: Copy`, we can go further and do a simple memory copy,
regardless of optimization level.

The same applies to `Rc`/`Arc::make_mut` when they must clone the data.

Fixed incorrect doc comment

">" is right alignment, not left

Auto merge of #77858 - ijackson:split-inclusive, r=KodrAus

Stabilize split_inclusive

### Contents of this MR

This stabilises:

 * `slice::split_inclusive`
 * `slice::split_inclusive_mut`
 * `str::split_inclusive`

Closes #72360.

### A possible concern

The proliferation of `split_*` methods is not particularly pretty.  The existence of `split_inclusive` seems to invite the addition of `rsplit_inclusive`, `splitn_inclusive`, etc.  We could instead have a more general API, along these kinds of lines maybe:
```
   pub fn split_generic('a,P,H>(&'a self, pat: P, how: H) -> ...
       where P: Pattern
       where H: SplitHow;

   pub fn split_generic_mut('a,P,H>(&'a mut self, pat: P, how: H) -> ...
       where P: Pattern
       where H: SplitHow;

   trait SplitHow {
       fn reverse(&self) -> bool;
       fn inclusive -> bool;
       fn limit(&self) -> Option<usize>;
   }

   pub struct SplitFwd;
   ...
   pub struct SplitRevInclN(pub usize);
```
But maybe that is worse.

### Let us defer that? ###

This seems like a can of worms.  I think we can defer opening it now; if and when we have something more general, these two methods can become convenience aliases.  But I thought I would mention it so the lang API team can consider it and have an opinion.

deprecate atomic::spin_loop_hint in favour of hint::spin_loop

Include `..` suggestion if fields are all wildcards

Update books

remove unstable deprecated Vec::remove_item

Use better ICE message when no MIR is available

The ICE message is somewhat confusing and overly specific - the issue is
that there's no MIR available.

This should make debugging these ICEs easier since the error tells you
what's actually wrong, not what it was trying to do when it failed.

cc https://github.com/rust-lang/rust/pull/80952#issuecomment-759198841

Auto merge of #80960 - Dylan-DPC:rollup-89tri8x, r=Dylan-DPC

Rollup of 10 pull requests

Successful merges:

 - #78901 (diagnostics: Note capturing closures can't be coerced to fns)
 - #79588 (Provide more information for HRTB lifetime errors involving closures)
 - #80232 (Remove redundant def_id lookups)
 - #80662 (Added support for i386-unknown-linux-gnu and i486-unknown-linux-gnu)
 - #80736 (use Once instead of Mutex to manage capture resolution)
 - #80796 (Update to LLVM 11.0.1)
 - #80859 (Fix --pretty=expanded with --remap-path-prefix)
 - #80922 (Revert "Auto merge of #76896 - spastorino:codegen-inline-fns2)
 - #80924 (Fix rustdoc --test-builder argument parsing)
 - #80935 (Rename `rustc_middle::lint::LevelSource` to `LevelAndSource`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

bump split_inclusive stabilization to 1.51.0

bump split_inclusive stabilization to 1.51.0

bump split_inclusive stabilization to 1.51.0

bump split_inclusive stabilization to 1.51.0

Update cargo

Always show suggestions in their own subwindows

Add a test case with lots of whitespace

Only suggest `..` if more than one field is missing

Specialize `..` help message for all fields vs. the rest

Pluralize 'parenthesis' correctly

It's 'parentheses', not 'parenthesis', when you have more than one.

Suggest `Variant(..)` if all of the mentioned fields are `_`

Simplify code

Co-authored-by: Esteban Kuber <estebank@users.noreply.github.com>

Suggest `_` and `..` if a pattern has too few fields

For example, this code:

    struct S(i32, f32);

    let S(x) = S(0, 1.0);

will make the compiler suggest either:

    let S(x, _) = S(0, 1.0);

or:

    let S(x, ..) = S(0, 1.0);

Rollup merge of #80935 - pierwill:rustc_middle-levelandsource, r=petrochenkov

Rename `rustc_middle::lint::LevelSource` to `LevelAndSource`

This continues work in https://github.com/rust-lang/rust/pull/80274 to improve code readability.

This naming follows a pattern seen elsewhere in the compiler (e.g. [`rustc_middle::ty::TypeAndMut`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TypeAndMut.html)).

Rollup merge of #80924 - teryror:issue-80893-fix, r=jyn514

Fix rustdoc --test-builder argument parsing

My suggested fix to issue #80893. I can actually hook Miri in there now.

I also fixed what I believe to be a typo in the option's help text.

Rollup merge of #80922 - spastorino:revert-inline-always-in-debug, r=wesleywiser

Revert "Auto merge of #76896 - spastorino:codegen-inline-fns2

This reverts commit ddf2cc7f8eb34f1a63b491d6a52e3e8208393c09, reversing
changes made to 937f629535f38c655267f1ed21ce6830f592f5df.

As `@alexcrichton` pointed out in https://github.com/rust-lang/rust/issues/80916 there's a problem with the taken approach.

Rollup merge of #80859 - jsgf:fix-pretty-remap, r=davidtwco

Fix --pretty=expanded with --remap-path-prefix

Per https://github.com/rust-lang/rust/issues/80832, using
--pretty=expanded and --remap-path-prefix results in an ICE.

This is becasue the session source files table is stored in remapped
form, whereas --pretty-expanded looks up unremapped files. This remaps
the path prefixes before lookup.

~~There don't appear to be any existing tests for --pretty=expanded; I'll look into
adding some.~~ Never mind, found the pretty tests.

Fixes #80832

Rollup merge of #80796 - cuviper:llvm-11.0.1, r=nikic

Update to LLVM 11.0.1

This updates to a new LLVM branch, rebased on the upstream `llvmorg-11.0.1`. All our patches applied cleanly except the fortanix unwind changes, which just needed a small adjustment in cmake files.

r? `@nikic`
Fixes https://github.com/rust-lang/rust/issues/73722

Rollup merge of #80736 - KodrAus:feat/lazy-resolve, r=dtolnay

use Once instead of Mutex to manage capture resolution

For #78299

This allows us to return borrows of the captured backtrace frames that are tied to a borrow of the Backtrace itself, instead of to some short-lived Mutex guard.

We could alternatively share `&Mutex<Capture>`s and lock on-demand, but then we could potentially forget to call `resolve()` before working with the capture. It also makes it semantically clearer what synchronization is needed on the capture.

cc `@seanchen1991` `@rust-lang/project-error-handling`

Rollup merge of #80662 - rxrbln:master, r=estebank

Added support for i386-unknown-linux-gnu and i486-unknown-linux-gnu

Support for both can be useful when creating new firmware, boot loaders,
or embedded operating systems.

Rollup merge of #80232 - bugadani:roundtrip, r=estebank

Remove redundant def_id lookups

Simplify `DefId -> LocalDefId -> HirId -> LocalDefId -> DefId` chains.

Rollup merge of #79588 - estebank:issue-79187, r=oli-obk

Provide more information for HRTB lifetime errors involving closures

Rollup merge of #78901 - arora-aman:fix_closure_coerce, r=estebank

diagnostics: Note capturing closures can't be coerced to fns

Fixes #72457, fixes #71895

r? `@estebank`

Auto merge of #79322 - jyn514:refactor-impl, r=estebank

Separate out a `hir::Impl` struct

This makes it possible to pass the `Impl` directly to functions, instead
of having to pass each of the many fields one at a time. It also
simplifies matches in many cases.

See `rustc_save_analysis::dump_visitor::process_impl` or `rustdoc::clean::clean_impl` for a good example of how this makes `impl`s easier to work with.

r? `@petrochenkov` maybe?

Separate out a `hir::Impl` struct

This makes it possible to pass the `Impl` directly to functions, instead
of having to pass each of the many fields one at a time. It also
simplifies matches in many cases.

Skip promoted mir of struct constructors & enum constructors

Consistently avoid constructing optimized MIR when not doing codegen

The optimized MIR for closures is being encoded unconditionally, while
being unnecessary for cargo check. This turns out to be especially
costly with MIR inlining enabled, since it triggers computation of
optimized MIR for all callees that are being examined for inlining
purposes.

Skip encoding of optimized MIR for closures, enum constructors, struct
constructors, and trait fns when not doing codegen, like it is already
done for other items since 49433.

Auto merge of #79670 - Nadrieril:uninhabited-query, r=estebank

Turn type inhabitedness into a query to fix `exhaustive_patterns` perf

We measured in https://github.com/rust-lang/rust/pull/79394 that enabling the [`exhaustive_patterns` feature](https://github.com/rust-lang/rust/issues/51085) causes significant perf degradation. It was conjectured that the culprit is type inhabitedness checking, and [I hypothesized](https://github.com/rust-lang/rust/pull/79394#issuecomment-733861149) that turning this computation into a query would solve most of the problem.

This PR turns `tcx.is_ty_uninhabited_from` into a query, and I measured a 25% perf gain on the benchmark that stress-tests `exhaustiveness_patterns`. This more than compensates for the 30% perf hit I measured [when creating it](https://github.com/rust-lang/rustc-perf/pull/801). We'll have to measure enabling the feature again, but I suspect this fixes the perf regression entirely.
I'd like a perf run on this PR obviously.
I made small atomic commits to help reviewing. The first one is just me discovering the "revisions" feature of the testing framework.

I believe there's a push to move things out of `rustc_middle` because it's huge. I guess `inhabitedness/mod.rs` could be moved out, but it's quite small. `DefIdForest` might be movable somewhere too. I don't know what the policy is for that.

Ping `@camelid` since you were interested in following along
`@rustbot` modify labels: +A-exhaustiveness-checking

Provide more information for HRTB lifetime errors involving closures

Make `DefIdForest` cheaper to clone

Since `DefIdForest` contains 0 or 1 elements the large majority of the
time, by allocating only in the >1 case we avoid almost all allocations,
compared to `Arc<SmallVec<[DefId;1]>>`. This shaves off 0.2% on the
benchmark that stresses uninhabitedness checking.

move WriteCloneIntoRaw into alloc::alloc

Bless profiler run make tests

Reorder MIR encoding checks

Start from least expensive checks when deciding whether to encode MIR or not.

No functional changes intended.

Auto merge of #80009 - jumbatm:issue79581-overeager-clashing-extern-decl, r=alexcrichton

Use tcx.symbol_name when determining clashing extern declarations.

Fixes #79581.

r? `@alexcrichton`

Turn type inhabitedness into a query

Add tests for uninhabited types

Deduplicate some tests using revisions

Prevent potential bug resulting from changing crate_hash query name

Return to defining crate_hash similarly to other query providers

Remove DepKind::CrateMetadata and pre-allocation of DepNodes

Remove much of the special-case handling around crate metadata
dependency tracking by replacing `DepKind::CrateMetadata` and the
pre-allocation of corresponding `DepNodes` with on-demand invocation
of the `crate_hash` query.

Auto merge of #78407 - oli-obk:ub_checkable_ctfe, r=RalfJung,pnkfelix

Make CTFE able to check for UB...

... by not doing any optimizations on the `const fn` MIR used in CTFE. This means we duplicate all `const fn`'s MIR now, once for CTFE, once for runtime. This PR is for checking the perf effect, so we have some data when talking about https://github.com/rust-lang/const-eval/blob/master/rfcs/0000-const-ub.md

To do this, we now have two queries for obtaining mir: `optimized_mir` and `mir_for_ctfe`. It is now illegal to invoke `optimized_mir` to obtain the MIR of a const/static item's initializer, an array length, an inline const expression or an enum discriminant initializer. For `const fn`, both `optimized_mir` and `mir_for_ctfe` work, the former returning the MIR that LLVM should use if the function is called at runtime. Similarly it is illegal to invoke `mir_for_ctfe` on regular functions.

This is all checked via appropriate assertions and I don't think it is easy to get wrong, as there should be no `mir_for_ctfe` calls outside the const evaluator or metadata encoding. Almost all rustc devs should keep using `optimized_mir` (or `instance_mir` for that matter).

Simplify regression test

Co-authored-by: Joshua Nelson <joshua@yottadb.com>

Update help message and add regression test

Fix rustdoc --test-builder argument parsing

Coverage computation needs access to the MIR, too

Auto merge of #80517 - wabain:issue-77880-infer-error-try-conversion-msg, r=davidtwco

Enhance type inference errors involving the `?` operator

This patch adds a special-cased note on type inference errors when the error span points to a `?` return. It also makes the primary label for such errors "cannot infer type of `?` error" in cases where before we would have only said "cannot infer type".

One beneficiary of this change is async blocks, where we can't explicitly annotate the return type and so may not generate any other help (#77880); this lets us at least print the error type we're converting from and anything we know about the type we can't fully infer. More generally, it signposts that an implicit conversion is happening that may have impeded type inference the user was expecting. We already do something similar for [mismatched type errors](https://github.com/rust-lang/rust/blob/2987785df3d46d5ff144a5c67fbb8f5cca798d78/src/test/ui/try-block/try-block-bad-type.stderr#L7).

The check for a relevant `?` operator is built into the existing HIR traversal which looks for places that could be annotated to resolve the error. That means we could identify `?` uses anywhere in the function that output the type we can't infer, but this patch just sticks to adding the note if the primary span given for the error has the operator; if there are other expressions where the type occurs and one of them is selected for the error instead, it's more likely that the `?` operator's implicit conversion isn't the sole cause of the inference failure and that adding an additional diagnostic would just be noise. I added a ui test for one such case.

The data about the `?` conversion is passed around in a `UseDiagnostic` enum that in theory could be used to add more of this kind of note in the future. It was also just easier to pass around than something with a more specific name. There are some follow-up refactoring commits for the code that generates the error label, which was already pretty involved and made a bit more complicated by this change.

Auto merge of #80499 - matthiaskrgr:red_clos, r=estebank

remove redundant closures (clippy::redundant_closure)

Auto merge of #80939 - JohnTitor:rollup-pymns4q, r=JohnTitor

Rollup of 8 pull requests

Successful merges:

 - #79757 (Replace tabs earlier in diagnostics)
 - #80600 (Add `MaybeUninit` method `array_assume_init`)
 - #80880 (Move some tests to more reasonable directories)
 - #80897 (driver: Use `atty` instead of rolling our own)
 - #80898 (Add another test case for #79808)
 - #80917 (core/slice: remove doc comment about scoped borrow)
 - #80927 (Replace a simple `if let` with the `matches` macro)
 - #80930 (fix typo in trait method mutability mismatch help)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Rollup merge of #80930 - euclio:trait-method-mutability-help, r=estebank

fix typo in trait method mutability mismatch help

Rollup merge of #80927 - LingMan:matches, r=estebank

Replace a simple `if let` with the `matches` macro

`@rustbot` modify labels +C-cleanup +T-compiler

Rollup merge of #80917 - epilys:patch-1, r=jyn514

core/slice: remove doc comment about scoped borrow

There's no need to scope the borrow in the doc example due to NLL.

[Playground link](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20mut%20v%20%3D%20%5B1%2C%200%2C%203%2C%200%2C%205%2C%206%5D%3B%0A%0A%20%20%20%20let%20(left%2C%20right)%20%3D%20v.split_at_mut(2)%3B%0A%20%20%20%20assert_eq!(left%2C%20%5B1%2C%200%5D)%3B%0A%20%20%20%20assert_eq!(right%2C%20%5B3%2C%200%2C%205%2C%206%5D)%3B%0A%20%20%20%20left%5B1%5D%20%3D%202%3B%0A%20%20%20%20right%5B1%5D%20%3D%204%3B%0A%0A%20%20%20%20assert_eq!(v%2C%20%5B1%2C%202%2C%203%2C%204%2C%205%2C%206%5D)%3B%0A%7D%0A) where changed code compiles

Rollup merge of #80898 - JohnTitor:vecdeque-another-case, r=lcnr

Add another test case for #79808

Taken from #80293.
Closes #80293

r? `@lcnr`

Rollup merge of #80897 - camelid:atty, r=jyn514

driver: Use `atty` instead of rolling our own

Fixes #80888.

Rationale:

- `atty` is widely used in the Rust ecosystem
- We already use it (in `rustc_errors` and other places)
- We shouldn't be rolling our own TTY detector when there's a
  widely-used, well-tested package that we can use

Rollup merge of #80880 - c410-f3r:tests-tests-tests, r=petrochenkov

Move some tests to more reasonable directories

The idea is to move `issues`/`ui` tests in small batches

r? `@petrochenkov`

Rollup merge of #80600 - CoffeeBlend:maybe_uninit_array_assume_init, r=dtolnay

Add `MaybeUninit` method `array_assume_init`

When initialising an array element-by-element, the conversion to the initialised array is done through `mem::transmute`, which is both ugly and does not work with const generics (see #61956). This PR proposes the associated method `array_assume_init`, matching the style of `slice_assume_init_*`:

```rust
unsafe fn array_assume_init<T, const N: usize>(array: [MaybeUninit<T>; N]) -> [T; N];
```

Example:
```rust
let mut array: [MaybeUninit<i32>; 3] = MaybeUninit::uninit_array();
array[0].write(0);
array[1].write(1);
array[2].write(2);

// SAFETY: Now safe as we initialised all elements
let array: [i32; 3] = unsafe {
     MaybeUninit::array_assume_init(array)
};
```

Things I'm unsure about:
* Should this be a method of array instead?
* Should the function be const?

Rollup merge of #79757 - jryans:long-line-tab-handling-early-expand, r=estebank

Replace tabs earlier in diagnostics

This replaces tabs earlier in the diagnostics emitting process, which allows various margin calculations to ignore the existence of tabs. It does add a string copy for the source lines that are emitted.

Fixes https://github.com/rust-lang/rust/issues/78438

r? `@estebank`

Auto merge of #80463 - tgnottingham:incr_comp_serial_mem_usage, r=oli-obk

Serialize incr comp structures to file via fixed-size buffer

Reduce a large memory spike that happens during serialization by writing
the incr comp structures to file by way of a fixed-size buffer, rather
than an unbounded vector.

Effort was made to keep the instruction count close to that of the
previous implementation. However, buffered writing to a file inherently
has more overhead than writing to a vector, because each write may
result in a handleable error. To reduce this overhead, arrangements are
made so that each LEB128-encoded integer can be written to the buffer
with only one capacity and error check. Higher-level optimizations in
which entire composite structures can be written with one capacity and
error check are possible, but would require much more work.

The performance is mostly on par with the previous implementation, with
small to moderate instruction count regressions. The memory reduction is
significant, however, so it seems like a worth-while trade-off.

driver: Use `atty` instead of rolling our own

Rationale:

- `atty` is widely used in the Rust ecosystem
- We already use it (in `rustc_errors` and other places)
- We shouldn't be rolling our own TTY detector when there's a
  widely-used, well-tested package that we can use

Add docs on performance

Update src/test/ui/async-await/issues/issue-78938-async-block.stderr

Co-authored-by: Esteban Kuber <estebank@users.noreply.github.com>

Auto merge of #76580 - rokob:iss76011, r=estebank

Suggest async {} for async || {}

Fixes #76011

This adds support for adding help diagnostics to the feature gating checks and
then uses it for the async_closure gate to add the extra bit of help
information as described in the issue.

Rename `rustc_middle::lint::LevelSource` to `LevelAndSource`

Move directly when Rc/Arc::make_mut splits from Weak

When only other `Weak` references remain, we can directly move the data
into the new unique allocation as a plain memory copy.

Specialize Rc/Arc::make_mut clones to try to avoid locals

As we did with `Box`, we can allocate an uninitialized `Rc` or `Arc`
beforehand, giving the optimizer a chance to skip the local value for
regular clones, or avoid any local altogether for `T: Copy`.

Specialize Box clones to try to avoid locals

For generic `T: Clone`, we can allocate an uninitialized box beforehand,
which gives the optimizer a chance to create the clone directly in the
heap. For `T: Copy`, we can go further and do a simple memory copy,
regardless of optimization level.

Replace a simple `if let` with the `matches` macro

Fix implementation

fix typo in trait method mutability mismatch help

Auto merge of #80928 - JohnTitor:rollup-sgerm3j, r=JohnTitor

Rollup of 9 pull requests

Successful merges:

 - #79997 (Emit a reactor for cdylib target on wasi)
 - #79998 (Use correct ABI for wasm32 by default)
 - #80042 (Split a func into cold/hot parts, reducing binary size)
 - #80324 (Explain method-call move errors in loops)
 - #80864 (std/core docs: fix wrong link in PartialEq)
 - #80870 (resolve: Simplify built-in macro table)
 - #80885 (rustdoc: Resolve `&str` as `str`)
 - #80904 (Fix small typo)
 - #80923 (Merge different function exits)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

differentiate functions in extern-compare-with-return-type.rs

Rollup merge of #80923 - LingMan:exits, r=varkor

Merge different function exits

`@rustbot` modify labels +C-cleanup +T-compiler

Rollup merge of #80904 - camelid:fix-small-typo, r=jonas-schievink

Fix small typo

transmutting -> transmuting

Rollup merge of #80885 - camelid:intra-doc-str-ref, r=jyn514

rustdoc: Resolve `&str` as `str`

People almost always are referring to `&str`, not `str`, so this will
save a manual link resolve in many cases.

Note that we already accept `&` (resolves to `reference`) in intra-doc
links, so this shouldn't cause breakage.

r? `@jyn514`

Rollup merge of #80870 - petrochenkov:bmactable, r=oli-obk

resolve: Simplify built-in macro table

We don't use full `SyntaxExtension`s from the table, only `SyntaxExtensionKind`s, and `Ident` in `register_builtin_macro` always had dummy span. This PR removes unnecessary data from the table and related function signatures.

Noticed when reviewing #80850.

Rollup merge of #80864 - ericseppanen:master, r=jyn514

std/core docs: fix wrong link in PartialEq

PartialEq doc was attempting to link to ``[`Eq`]`` but instead we got a link to `` `eq` ``. Disambiguate with `trait@Eq`.

You can see the bad link [here](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html) (Second sentence, "floating point types implement PartialEq but not Eq").

Rollup merge of #80324 - Aaron1011:loop-move-fn-self, r=oli-obk

Explain method-call move errors in loops

PR #73708 added a more detailed explanation of move errors that occur
due to a call to a method that takes `self`. This PR extends that logic
to work when a move error occurs due to a method call in the previous
iteration of a loop.