Auto merge of #72905 - JohnTitor:rollup-phtyo5i, r=JohnTitor

Rollup of 10 pull requests

Successful merges:

 - #72775 (Return early to avoid ICE)
 - #72795 (Add a test for `$:ident` in proc macro input)
 - #72822 (remove trivial calls to mk_const)
 - #72825 (Clarify errors and warnings about the transition to the new asm!)
 - #72827 (changed *nix to Unix-like)
 - #72880 (Clean up E0637 explanation)
 - #72886 (Remove allow missing_debug_implementations for MaybeUninit)
 - #72889 (rustc: Remove the `--passive-segments` LLD flag on wasm)
 - #72891 (Add associated consts MIN/MAX for Wrapping<Int>)
 - #72893 (test miri-unleash TLS accesses)

Failed merges:

r? @ghost

Author: bors

README.md

@@ -23,7 +23,7 @@ or reading the [rustc dev guide][rustcguidebuild].
 
 [rustcguidebuild]: https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html
 
-### Building on *nix
+### Building on Unix-like system
 1. Make sure you have installed the dependencies:
 
    * `g++` 5.1 or later or `clang++` 3.5 or later

src/libcore/macros/mod.rs

@@ -1315,7 +1315,7 @@ pub(crate) mod builtin {
     #[unstable(
         feature = "llvm_asm",
         issue = "70173",
-        reason = "LLVM-style inline assembly will never be stabilized, prefer using asm! instead"
+        reason = "prefer using the new asm! syntax instead"
     )]
     #[rustc_builtin_macro]
     #[macro_export]

src/libcore/mem/maybe_uninit.rs

@@ -214,7 +214,6 @@ use crate::mem::ManuallyDrop;
 /// remain `#[repr(transparent)]`. That said, `MaybeUninit<T>` will *always* guarantee that it has
 /// the same size, alignment, and ABI as `T`; it's just that the way `MaybeUninit` implements that
 /// guarantee may evolve.
-#[allow(missing_debug_implementations)]
 #[stable(feature = "maybe_uninit", since = "1.36.0")]
 // Lang item so we can wrap other types in it. This is useful for generators.
 #[lang = "maybe_uninit"]

src/libcore/num/wrapping.rs

@@ -337,14 +337,10 @@ Basic usage:
 #![feature(wrapping_int_impl)]
 use std::num::Wrapping;
 
-assert_eq!(<Wrapping<", stringify!($t), ">>::min_value(), ",
-"Wrapping(", stringify!($t), "::min_value()));
+assert_eq!(<Wrapping<", stringify!($t), ">>::MIN, Wrapping(", stringify!($t), "::MIN));
 ```"),
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                #[inline]
-                pub const fn min_value() -> Self {
-                    Wrapping(<$t>::min_value())
-                }
+                pub const MIN: Self = Self(<$t>::MIN);
             }
 
             doc_comment! {
@@ -358,14 +354,10 @@ Basic usage:
 #![feature(wrapping_int_impl)]
 use std::num::Wrapping;
 
-assert_eq!(<Wrapping<", stringify!($t), ">>::max_value(), ",
-"Wrapping(", stringify!($t), "::max_value()));
+assert_eq!(<Wrapping<", stringify!($t), ">>::MAX, Wrapping(", stringify!($t), "::MAX));
 ```"),
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                #[inline]
-                pub const fn max_value() -> Self {
-                    Wrapping(<$t>::max_value())
-                }
+                pub const MAX: Self = Self(<$t>::MAX);
             }
 
             doc_comment! {

src/librustc_builtin_macros/asm.rs

@@ -33,7 +33,10 @@ fn parse_args<'a>(
 
     // Detect use of the legacy llvm_asm! syntax (which used to be called asm!)
     if p.look_ahead(1, |t| *t == token::Colon || *t == token::ModSep) {
-        let mut err = ecx.struct_span_err(sp, "legacy asm! syntax is no longer supported");
+        let mut err =
+            ecx.struct_span_err(sp, "the legacy LLVM-style asm! syntax is no longer supported");
+        err.note("consider migrating to the new asm! syntax specified in RFC 2873");
+        err.note("alternatively, switch to llvm_asm! to keep your code working as it is");
 
         // Find the span of the "asm!" so that we can offer an automatic suggestion
         let asm_span = sp.from_inner(InnerSpan::new(0, 4));

src/librustc_codegen_ssa/back/linker.rs

@@ -1010,9 +1010,6 @@ impl<'a> WasmLd<'a> {
         //   sharing memory and instantiating the module multiple times. As a
         //   result if it were exported then we'd just have no sharing.
         //
-        // * `--passive-segments` - all memory segments should be passive to
-        //   prevent each module instantiation from reinitializing memory.
-        //
         // * `--export=__wasm_init_memory` - when using `--passive-segments` the
         //   linker will synthesize this function, and so we need to make sure
         //   that our usage of `--export` below won't accidentally cause this
@@ -1026,7 +1023,6 @@ impl<'a> WasmLd<'a> {
             cmd.arg("--shared-memory");
             cmd.arg("--max-memory=1073741824");
             cmd.arg("--import-memory");
-            cmd.arg("--passive-segments");
             cmd.arg("--export=__wasm_init_memory");
             cmd.arg("--export=__wasm_init_tls");
             cmd.arg("--export=__tls_size");

src/librustc_error_codes/error_codes/E0637.md

@@ -1,6 +1,7 @@
 An underscore `_` character has been used as the identifier for a lifetime.
 
-Erroneous example:
+Erroneous code example:
+
 ```compile_fail,E0106,E0637
 fn longest<'_>(str1: &'_ str, str2: &'_ str) -> &'_ str {
          //^^ `'_` is a reserved lifetime name
@@ -11,13 +12,15 @@ fn longest<'_>(str1: &'_ str, str2: &'_ str) -> &'_ str {
     }
 }
 ```
+
 `'_`, cannot be used as a lifetime identifier because it is a reserved for the
 anonymous lifetime. To fix this, use a lowercase letter such as 'a, or a series
 of lowercase letters such as `'foo`.  For more information, see [the
 book][bk-no].  For more information on using the anonymous lifetime in rust
 nightly, see [the nightly book][bk-al].
 
 Corrected example:
+
 ```
 fn longest<'a>(str1: &'a str, str2: &'a str) -> &'a str {
     if str1.len() > str2.len() {

src/librustc_middle/mir/interpret/error.rs

@@ -523,12 +523,12 @@ impl fmt::Display for UnsupportedOpInfo {
         match self {
             Unsupported(ref msg) => write!(f, "{}", msg),
             ReadForeignStatic(did) => {
-                write!(f, "cannot read from foreign (extern) static {:?}", did)
+                write!(f, "cannot read from foreign (extern) static ({:?})", did)
             }
             NoMirFor(did) => write!(f, "no MIR body is available for {:?}", did),
             ReadPointerAsBytes => write!(f, "unable to turn pointer into raw bytes",),
             ReadBytesAsPointer => write!(f, "unable to turn bytes into a pointer"),
-            ThreadLocalStatic(did) => write!(f, "accessing thread local static {:?}", did),
+            ThreadLocalStatic(did) => write!(f, "cannot access thread local static ({:?})", did),
         }
     }
 }

src/librustc_middle/ty/structural_impls.rs

@@ -1019,7 +1019,11 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::Const<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         let ty = self.ty.fold_with(folder);
         let val = self.val.fold_with(folder);
-        folder.tcx().mk_const(ty::Const { ty, val })
+        if ty != self.ty || val != self.val {
+            folder.tcx().mk_const(ty::Const { ty, val })
+        } else {
+            *self
+        }
     }
 
     fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {

src/librustc_mir/transform/check_consts/ops.rs

@@ -12,9 +12,6 @@ use super::ConstCx;
 
 /// An operation that is not *always* allowed in a const context.
 pub trait NonConstOp: std::fmt::Debug {
-    /// Whether this operation can be evaluated by miri.
-    const IS_SUPPORTED_IN_MIRI: bool = true;
-
     /// Returns the `Symbol` corresponding to the feature gate that would enable this operation,
     /// or `None` if such a feature gate does not exist.
     fn feature_gate() -> Option<Symbol> {
@@ -356,8 +353,6 @@ impl NonConstOp for StaticAccess {
 #[derive(Debug)]
 pub struct ThreadLocalAccess;
 impl NonConstOp for ThreadLocalAccess {
-    const IS_SUPPORTED_IN_MIRI: bool = false;
-
     fn emit_error(&self, ccx: &ConstCx<'_, '_>, span: Span) {
         struct_span_err!(
             ccx.tcx.sess,