…e stored value matches

Moves into functions are typically implemented with pointer passing
rather than memcpy's at the llvm-ir level, so allow moves into
functions.

So that devs on aarch64 can also bless tests.

…ccount.

…bilee

simd intrinsics: add simd_shuffle_generic and other missing intrinsics

Also tweak the simd_shuffle docs a bit.

r? `@calebzulawski`

…ns-in-derive-macro, r=oli-obk

Suppress suggestions in derive macro

close rust-lang#118809

I suppress warnings inside derive macros.

For example, the compiler emits following error by a program described in rust-lang#118809 (comment) with a suggestion that indicates invalid syntax.

```
error[E0308]: `?` operator has incompatible types
 --> src/main.rs:3:17
  |
3 | #[derive(Debug, Deserialize)]
  |                 ^^^^^^^^^^^ expected `u32`, found `u64`
  |
  = note: `?` operator cannot convert from `u64` to `u32`
  = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
  |
3 | #[derive(Debug, Deserialize.try_into().unwrap())]
  |                            ++++++++++++++++++++

For more information about this error, try `rustc --explain E0308`.
error: could not compile `serde_test` (bin "serde_test") due to 2 previous errors
```

In this PR, suggestions to cast are suppressed.

```
error[E0308]: `?` operator has incompatible types
 --> src/main.rs:3:17
  |
3 | #[derive(Debug, Deserialize)]
  |                 ^^^^^^^^^^^ expected `u32`, found `u64`
  |
  = note: `?` operator cannot convert from `u64` to `u32`
  = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0308`.
error: could not compile `serde_test` (bin "serde_test") due to 2 previous errors
```

large_assignments: Allow moves into functions

Moves into functions are typically implemented with pointer passing
rather than memcpy's at the llvm-ir level, so allow moves into
functions.

Part of the "Differentiate between Operand::Move and Operand::Copy" step of rust-lang#83518.

r? `@oli-obk` (who I think is still E-mentor?)

…tion, r=fmease

Take empty `where` bounds into account when suggesting predicates

Fixes rust-lang#120838

…ler-errors

interpret/write_discriminant: when encoding niched variant, ensure the stored value matches

Cc rust-lang/unsafe-code-guidelines#487

interpret: rename ReadExternStatic → ExternStatic

This error shows up for reads and writes, so `ReadExternStatic` is misleading.

…ozkan

Adapt `llvm-has-rust-patches` validation to take `llvm-config` into account.

This adapts an assertion that was added in rust-lang#119556.

The current assertion does not take the `llvm-config` setting into accounts, which does not match the `llvm-has-rust-patches` documentation, which states:

> This would be used in conjunction with either an llvm-config or build.submodules = false.

(It also breaks my workflow: I build LLVM separately, but do have the rust patches applied).

---

**edit:** Originally this PR just removed the assertion, but it now implements the alternative mentioned here:

An alternative fix would be to take `llvm-config` into account in the assertion, but to me the assertion seems to provide little value, thus the simpler fix of just removing it.

cc `@onur-ozkan,` in case I'm missing a reason to keep the assertion.

…compiler-errors

don't skip coercions for types with errors

fixes rust-lang#120884

… r=oli-obk

Print kind of coroutine closure

Make sure that we print "async closure" when we have an async closure, rather than calling it generically a ["coroutine-closure"](rust-lang#120361).

Fixes rust-lang#120886

r? oli-obk