Update tests for grouped nll move errors

Group move errors before reporting, add suggestions

Auto merge of #51139 - vakaras:issue-50716, r=nikomatsakis

Fix NLL issue 50716 and add a regression test.

Fix for NLL issue #50716.

r? @nikomatsakis

Update MIR opt tests

Generate a direct assignment in MIR for `let x = y;`

rustfmt various files

change the `enter_canonical_trait_query` method to give a fulfill cx

update comments

rename `prequery` to `try_fast_path`

pull out `ParamEnvAnd` and remove `QueryKey`

Auto merge of #51852 - oli-obk:miri_fix, r=Zoxc

Don't use `ParamEnv::reveal_all()` if there is a real one available

fixes #51841

r? @Zoxc

run rustfmt

Auto merge of #51850 - abarth:draw_again, r=cramertj

[fuchsia] Update zx_cprng_draw to target semantics

This change is the final step in improving the semantics of
zx_cprng_draw. Now the syscall always generates the requested number of
bytes. If the syscall would have failed to generate the requested number
of bytes, the syscall either terminates the entire operating system or
terminates the calling process, depending on whether the error is a
result of the kernel misbehaving or the userspace program misbehaving.

don't use Iterator and zip but just invoke `next` manually

This micro-optimizes some if checks away; the compiler may already
have been doing it, not sure.

Don't use `ParamEnv::reveal_all()` if there is a real one available

Fix the error of selecting obligation by not running the borrow checker.

Move regression test from `compile-fail/` to `ui/` test directory.

Fix the regression test for issue 50716.

Fix NLL issue 50716 and add a regression test.

[fuchsia] Update zx_cprng_draw to target semantics

This change is the final step in improving the semantics of
zx_cprng_draw. Now the syscall always generates the requested number of
bytes. If the syscall would have failed to generate the requested number
of bytes, the syscall either terminates the entire operating system or
terminates the calling process, depending on whether the error is a
result of the kernel misbehaving or the userspace program misbehaving.

avoid use of vectors etc

extract `places_conflict` into its own module

Auto merge of #51356 - Zoxc:encode-cleanup, r=michaelwoerister

Make opaque::Encoder append-only and make it infallible

move into `provide` methods

rename to `shrink_to_tcx_lifetime`

Document that Layout::from_size_align does not allow align=0

This was already implied since zero is not a power of two, but maybe
worth pointing out.

extend comment to note complications around lifetimes

syntax_pos: Store multibyte char size as u8 instead of u32.

Add comments to analzye_filemap().

Add SSE2 accelerated version of FileMap analysis.

Use u32 instead of usize of encoding byte count of multi-byte chars.

Update CodeMap tests after changing FileMap construction.

Remove the now redundant CodeMap::new_filemap_with_lines() method.

Make FileMap::{lines, multibyte_chars, non_narrow_chars} non-mutable.

Detect overflows of non u32 shifts

pacify the mercilous tidy

improve comments on `dropck_outlives`

Auto merge of #51496 - petrochenkov:mhelper2, r=nikomatsakis

Implement `#[macro_export(local_inner_macros)]` (a solution for the macro helper import problem)

Implement a solution for the macro helper issue discussed in https://github.com/rust-lang/rust/issues/35896 as described in https://github.com/rust-lang/rust/issues/35896#issuecomment-395977901.

Macros exported from libraries can be marked with `#[macro_export(local_inner_macros)]` and this annotation changes how nested macros in them are resolved.

If we have a fn-like macro call `ident!(...)` and `ident` comes from a `macro_rules!` macro marked with  `#[macro_export(local_inner_macros)]` then it's replaced with `$crate::ident!(...)` and resolved as such (`$crate` gets the same context as `ident`).

improve comment on instantiate NLL query result fn

remove `either` dependency we are not using

rename `upcast` to `cast_to_tcx_lifetime` and improve comment

fix wrong query description

merge all the `type_op_foo` modules into one as they are so trivial

use query boiler plate for `normalize_projection_ty` too

use query boilerplate for prove-predicate -- slightly inefficient

This requires us to allocate a single entry vector we didn't use to
allocate. I doubt this makes a difference in practice, as this only
occurs for cache misses.

use query boilerplate for subtype

use query boilerplate for `normalize`

extract out query boilerplate and use for `Eq`

Implement `#[macro_export(local_inner_macros)]`

Update ui tests

nit: don't import Debug directly

Make opaque::Encoder append-only and make it infallible

Explain the lack of item recursion

Deduplicate async's impl Trait id lowering

Add a convenience method for getting the impl Trait `NodeId` of an `IsAysnc`

Document the `make_ret_async` argument's `NodeId`

Undo if let -> match conversion

Auto merge of #51835 - tmccombs:stable-int-to-from-bytes, r=joshtriplett

Stabilize to_bytes and from_bytes for integers.

Fixes #49792

Fix rebase fallout

Don't visit the `impl Trait` item twice

Don't use `println` in the compiler

Update tests

Don't generate `DefId`s for impl trait in trait methods

Generate `DefId`s for the impl trait of `async` functions

Also place method impl trait into the surrounding module

fixup

Generate `DefId`s for impl Trait in the def_collector

Don't generate a new NodeId for universal impl Trait

Generate the `NodeId` for `existential type` in the AST

Cleanup in preparation of generic extraction

Auto merge of #51815 - oli-obk:lowering_cleanups2, r=nikomatsakis

Lowering cleanups [2/N]

Double indirections are unnecessary

Optimize RefCell refcount tracking

Stabilize to_bytes and from_bytes for integers.

Fixes #49792

Fix the error reference for LocalKey::try_with

Auto merge of #51598 - Pazzaz:master, r=sfackler

Optimize sum of Durations by using custom function

The current `impl Sum for Duration` uses `fold` to perform several `add`s (or really `checked_add`s) of durations. In doing so, it has to guarantee the number of nanoseconds is valid after every addition. If you squeese the current implementation into a single function it looks kind of like this:
````rust
fn sum<I: Iterator<Item = Duration>>(iter: I) -> Duration {
    let mut sum = Duration::new(0, 0);
    for rhs in iter {
        if let Some(mut secs) = sum.secs.checked_add(rhs.secs) {
            let mut nanos = sum.nanos + rhs.nanos;
            if nanos >= NANOS_PER_SEC {
                nanos -= NANOS_PER_SEC;
                if let Some(new_secs) = secs.checked_add(1) {
                    secs = new_secs;
                } else {
                    panic!("overflow when adding durations");
                }
            }
            sum = Duration { secs, nanos }
        } else {
            panic!("overflow when adding durations");
        }
    }
    sum
}
````
We only need to check if `nanos` is in the correct range when giving our final answer so we can have a more optimized version like so:
````rust
fn sum<I: Iterator<Item = Duration>>(iter: I) -> Duration {
    let mut total_secs: u64 = 0;
    let mut total_nanos: u64 = 0;

    for entry in iter {
        total_secs = total_secs
            .checked_add(entry.secs)
            .expect("overflow in iter::sum over durations");
        total_nanos = match total_nanos.checked_add(entry.nanos as u64) {
            Some(n) => n,
            None => {
                total_secs = total_secs
                    .checked_add(total_nanos / NANOS_PER_SEC as u64)
                    .expect("overflow in iter::sum over durations");
                (total_nanos % NANOS_PER_SEC as u64) + entry.nanos as u64
            }
        };
    }
    total_secs = total_secs
        .checked_add(total_nanos / NANOS_PER_SEC as u64)
        .expect("overflow in iter::sum over durations");
    total_nanos = total_nanos % NANOS_PER_SEC as u64;
    Duration {
        secs: total_secs,
        nanos: total_nanos as u32,
    }
}
````
We now only convert `total_nanos` to `total_secs` (1) if `total_nanos` overflows and (2) at the end of the function when we have to output a valid `Duration`. This gave a 5-22% performance improvement when I benchmarked it, depending on how big the `nano` value of the `Duration`s in `iter` were.

Auto merge of #51773 - oli-obk:cleanup_impl_trait, r=nikomatsakis

Don't inspect the generated existential type items

r? @nikomatsakis

My debugging led me to the `hir::ItemExistential(..)` checks, which are entirely unnecessary because we never use the items directly. The issue was that items were iterated over in a random order (due to hashmaps), so if you checked the `ItemExistential` before the function that has the actual return `impl Trait`, you'd run into those ICEs you encountered.

add edition compiletest header + fix tests

lower case some feature gate messages

Auto merge of #51149 - zackmdavis:․․․_to_․․=, r=nikomatsakis

lint to favor `..=` over `...` range patterns; migrate to `..=` throughout codebase

We probably need an RFC to actually deprecate the `...` syntax, but here's a candidate implementation for the lint considered in #51043. (My local build is super flaky, but hopefully I got all of the test revisions.)

Auto merge of #51814 - MajorBreakfast:local-task-obj, r=cramertj

Add `LocalTaskObj` to `core::task`

- Splits `libcore/task.rs` into submodules
- Adds `LocalTaskObj` and `SpawnLocalObjError` (-> [Commit for this](https://github.com/rust-lang/rust/commit/433e6b31a75eea5ce45493acc63eae462d740338))

Note: To make reviewing easy, both actions have their own commit

r? @cramertj

Move spawn errors into executor.rs

Nested `LocalTaskObj` in `TaskObj`, remove `SpawnErrorObj` conversions

Auto merge of #51756 - nielx:fix/librustdoc, r=GuillaumeGomez

Haiku: set stack size to 16 MB on Haiku, use 32 MB on other platforms

The maximum stack size on Haiku is set to 16 MB (see [the Haiku source](https://git.haiku-os.org/haiku/tree/headers/private/system/thread_defs.h#n17)). With this change rustdoc will also work on Haiku.

do not re-create the `LocationTable` for every path

:facepalm:

convert query-type-op to create query-region-constraint directly

add a streamlined `instantiate_query_result` method for NLL queries

convert `dropck_outlives` type-op to use the query

introduce `QueryKey` separation

extract more helpers from instantiating query result

WIP fix error messages for propagate_approximated_shorter_to_static_no_bound

Auto merge of #51725 - Mark-Simulacrum:no-llvm, r=kennytm

Do not build LLVM tools for any of the tools

None of the tools in the list should need LLVM tools themselves as far as I can
tell; if this is incorrect, we can re-enable the tool building later.

The primary reason for doing this is that rust-central-station uses the
BuildManifest tool and building LLVM there is not cached: it takes ~1.5
hours on the 2 core machine. This commit should make nightlies and
stable releases much faster.

Followup to https://github.com/rust-lang/rust/pull/51459, r? @kennytm

I'm mostly relying on CI to test this so probably don't roll it up; I'm not sure how to (and not particularly inclined to) wait for multiple hours to test this locally. I imagine that the failures should be fairly obvious when/if encountered.

Update rustdoc

Flatten some occurrences of `[P<T>]` to `[T]`

Add `LocalTaskObj`

instantiate closure requirements as query-region-constraints [WIP]

Marked as WIP because it invalidates some tests.

transition to `Fallible`

introduce `Normalizable` trait for things directly normalizable

convert `prove_predicate` into a query

convert `predicates` to operate on 1 predicate at a time

make `Subtype` a true query