Auto merge of #59922 - Centril:rollup-0qmx4jg, r=Centril

Rollup of 8 pull requests

Successful merges:

 - #59781 (Remove check_match from const_eval)
 - #59820 (proc_macro: stop using LEB128 for RPC.)
 - #59846 (clarify what the item is in "not a module" error)
 - #59847 (Error when using `catch` after `try`)
 - #59859 (Suggest removing `?` to resolve type errors.)
 - #59862 (Tweak unstable diagnostic output)
 - #59866 (Recover from missing semicolon based on the found token)
 - #59892 (Impl RawFd conversion traits for WASI TcpListener, TcpStream and UdpSocket)

Failed merges:

r? @ghost

211 files changed, 1327 insertions, 631 deletions

diff --git a/src/libproc_macro/bridge/rpc.rs b/src/libproc_macro/bridge/rpc.rs
index 4289f33ffd5..5018be74f89 100644
--- a/src/libproc_macro/bridge/rpc.rs
+++ b/src/libproc_macro/bridge/rpc.rs
@@ -24,32 +24,22 @@ pub(super) trait DecodeMut<'a, 's, S>: Sized {
 }
 
 macro_rules! rpc_encode_decode {
-    (uleb128 $ty:ty) => {
+    (le $ty:ty) => {
         impl<S> Encode<S> for $ty {
-            fn encode(mut self, w: &mut Writer, s: &mut S) {
-                let mut byte = 0x80;
-                while byte & 0x80 != 0 {
-                    byte = (self & 0x7f) as u8;
-                    self >>= 7;
-                    if self != 0 {
-                        byte |= 0x80;
-                    }
-                    byte.encode(w, s);
-                }
+            fn encode(self, w: &mut Writer, _: &mut S) {
+                w.write_all(&self.to_le_bytes()).unwrap();
             }
         }
 
         impl<S> DecodeMut<'_, '_, S> for $ty {
-            fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
-                let mut byte = 0x80;
-                let mut v = 0;
-                let mut shift = 0;
-                while byte & 0x80 != 0 {
-                    byte = u8::decode(r, s);
-                    v |= ((byte & 0x7f) as Self) << shift;
-                    shift += 7;
-                }
-                v
+            fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
+                const N: usize = ::std::mem::size_of::<$ty>();
+
+                let mut bytes = [0; N];
+                bytes.copy_from_slice(&r[..N]);
+                *r = &r[N..];
+
+                Self::from_le_bytes(bytes)
             }
         }
     };
@@ -136,8 +126,8 @@ impl<S> DecodeMut<'_, '_, S> for u8 {
     }
 }
 
-rpc_encode_decode!(uleb128 u32);
-rpc_encode_decode!(uleb128 usize);
+rpc_encode_decode!(le u32);
+rpc_encode_decode!(le usize);
 
 impl<S> Encode<S> for bool {
     fn encode(self, w: &mut Writer, s: &mut S) {
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
index 19663161fe3..9c899fab59e 100644
--- a/src/librustc/infer/error_reporting/mod.rs
+++ b/src/librustc/infer/error_reporting/mod.rs
@@ -604,13 +604,39 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 source,
                 ref prior_arms,
                 last_ty,
+                discrim_hir_id,
                 ..
             } => match source {
                 hir::MatchSource::IfLetDesugar { .. } => {
                     let msg = "`if let` arms have incompatible types";
                     err.span_label(cause.span, msg);
                 }
-                hir::MatchSource::TryDesugar => {}
+                hir::MatchSource::TryDesugar => {
+                    if let Some(ty::error::ExpectedFound { expected, .. }) = exp_found {
+                        let discrim_expr = self.tcx.hir().expect_expr_by_hir_id(discrim_hir_id);
+                        let discrim_ty = if let hir::ExprKind::Call(_, args) = &discrim_expr.node {
+                            let arg_expr = args.first().expect("try desugaring call w/out arg");
+                            self.in_progress_tables.and_then(|tables| {
+                                tables.borrow().expr_ty_opt(arg_expr)
+                            })
+                        } else {
+                            bug!("try desugaring w/out call expr as discriminant");
+                        };
+
+                        match discrim_ty {
+                            Some(ty) if expected == ty => {
+                                let source_map = self.tcx.sess.source_map();
+                                err.span_suggestion(
+                                    source_map.end_point(cause.span),
+                                    "try removing this `?`",
+                                    "".to_string(),
+                                    Applicability::MachineApplicable,
+                                );
+                            },
+                            _ => {},
+                        }
+                    }
+                }
                 _ => {
                     let msg = "`match` arms have incompatible types";
                     err.span_label(cause.span, msg);
diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs
index d91c08b070a..b875bfdfa9f 100644
--- a/src/librustc/traits/mod.rs
+++ b/src/librustc/traits/mod.rs
@@ -226,6 +226,7 @@ pub enum ObligationCauseCode<'tcx> {
         source: hir::MatchSource,
         prior_arms: Vec<Span>,
         last_ty: Ty<'tcx>,
+        discrim_hir_id: hir::HirId,
     },
 
     /// Computing common supertype in the pattern guard for the arms of a match expression
diff --git a/src/librustc/traits/structural_impls.rs b/src/librustc/traits/structural_impls.rs
index f3a800bf46d..0711f3539e5 100644
--- a/src/librustc/traits/structural_impls.rs
+++ b/src/librustc/traits/structural_impls.rs
@@ -519,6 +519,7 @@ impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCauseCode<'a> {
                 source,
                 ref prior_arms,
                 last_ty,
+                discrim_hir_id,
             } => {
                 tcx.lift(&last_ty).map(|last_ty| {
                     super::MatchExpressionArm {
@@ -526,6 +527,7 @@ impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCauseCode<'a> {
                         source,
                         prior_arms: prior_arms.clone(),
                         last_ty,
+                        discrim_hir_id,
                     }
                 })
             }
diff --git a/src/librustc_mir/const_eval.rs b/src/librustc_mir/const_eval.rs
index 33715b749f9..4c8ab361e04 100644
--- a/src/librustc_mir/const_eval.rs
+++ b/src/librustc_mir/const_eval.rs
@@ -615,22 +615,9 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
     let cid = key.value;
     let def_id = cid.instance.def.def_id();
 
-    if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
-        let tables = tcx.typeck_tables_of(def_id);
-
-        // Do match-check before building MIR
-        // FIXME(#59378) check_match may have errored but we're not checking for that anymore
-        tcx.check_match(def_id);
-
-        if let hir::BodyOwnerKind::Const = tcx.hir().body_owner_kind_by_hir_id(id) {
-            tcx.mir_const_qualif(def_id);
-        }
-
-        // Do not continue into miri if typeck errors occurred; it will fail horribly
-        if tables.tainted_by_errors {
-            return Err(ErrorHandled::Reported)
-        }
-    };
+    if def_id.is_local() && tcx.typeck_tables_of(def_id).tainted_by_errors {
+        return Err(ErrorHandled::Reported);
+    }
 
     let (res, ecx) = eval_body_and_ecx(tcx, cid, None, key.param_env);
     res.and_then(|place| {
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 5216156c0ca..ffc783ae9f2 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -3731,9 +3731,16 @@ impl<'a> Resolver<'a> {
                             def, path.len() - i - 1
                         ));
                     } else {
+                        let label = format!(
+                            "`{}` is {} {}, not a module",
+                            ident,
+                            def.article(),
+                            def.kind_name(),
+                        );
+
                         return PathResult::Failed {
                             span: ident.span,
-                            label: format!("not a module `{}`", ident),
+                            label,
                             suggestion: None,
                             is_error_from_last_segment: is_last,
                         };
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
index affd3a2d16a..032821e6d42 100644
--- a/src/librustc_typeck/check/_match.rs
+++ b/src/librustc_typeck/check/_match.rs
@@ -732,6 +732,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
                         source: match_src,
                         prior_arms: other_arms.clone(),
                         last_ty: prior_arm_ty.unwrap(),
+                        discrim_hir_id: discrim.hir_id,
                     })
                 };
                 coercion.coerce(self, &cause, &arm.body, arm_ty);
diff --git a/src/libstd/sys/wasi/ext/io.rs b/src/libstd/sys/wasi/ext/io.rs
index cf75a96d28c..12afd1d42dc 100644
--- a/src/libstd/sys/wasi/ext/io.rs
+++ b/src/libstd/sys/wasi/ext/io.rs
@@ -5,6 +5,7 @@
 use crate::fs;
 use crate::io;
 use crate::sys;
+use crate::net;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 
 /// Raw file descriptors.
@@ -50,6 +51,60 @@ pub trait IntoRawFd {
     fn into_raw_fd(self) -> RawFd;
 }
 
+impl AsRawFd for net::TcpStream {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().fd().as_raw()
+    }
+}
+
+impl FromRawFd for net::TcpStream {
+    unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
+        net::TcpStream::from_inner(sys::net::TcpStream::from_inner(fd))
+    }
+}
+
+impl IntoRawFd for net::TcpStream {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().into_fd().into_raw()
+    }
+}
+
+impl AsRawFd for net::TcpListener {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().fd().as_raw()
+    }
+}
+
+impl FromRawFd for net::TcpListener {
+    unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
+        net::TcpListener::from_inner(sys::net::TcpListener::from_inner(fd))
+    }
+}
+
+impl IntoRawFd for net::TcpListener {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().into_fd().into_raw()
+    }
+}
+
+impl AsRawFd for net::UdpSocket {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().fd().as_raw()
+    }
+}
+
+impl FromRawFd for net::UdpSocket {
+    unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
+        net::UdpSocket::from_inner(sys::net::UdpSocket::from_inner(fd))
+    }
+}
+
+impl IntoRawFd for net::UdpSocket {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().into_fd().into_raw()
+    }
+}
+
 impl AsRawFd for fs::File {
     fn as_raw_fd(&self) -> RawFd {
         self.as_inner().fd().as_raw()
diff --git a/src/libstd/sys/wasi/net.rs b/src/libstd/sys/wasi/net.rs
index 1579aa4b572..5486cdec4c0 100644
--- a/src/libstd/sys/wasi/net.rs
+++ b/src/libstd/sys/wasi/net.rs
@@ -4,8 +4,12 @@ use crate::net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr};
 use crate::time::Duration;
 use crate::sys::{unsupported, Void};
 use crate::convert::TryFrom;
+use crate::sys::fd::{WasiFd};
+use crate::sys_common::FromInner;
 
-pub struct TcpStream(Void);
+pub struct TcpStream {
+    fd: WasiFd,
+}
 
 impl TcpStream {
     pub fn connect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
@@ -17,89 +21,111 @@ impl TcpStream {
     }
 
     pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn read(&self, _: &mut [u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn read_vectored(&self, _: &mut [IoVecMut<'_>]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn write(&self, _: &[u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn write_vectored(&self, _: &[IoVec<'_>]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn shutdown(&self, _: Shutdown) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn duplicate(&self) -> io::Result<TcpStream> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_nodelay(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
+    }
+
+    pub fn fd(&self) -> &WasiFd {
+        &self.fd
+    }
+
+    pub fn into_fd(self) -> WasiFd {
+        self.fd
+    }
+}
+
+impl FromInner<u32> for TcpStream {
+    fn from_inner(fd: u32) -> TcpStream {
+        unsafe {
+            TcpStream {
+                fd: WasiFd::from_raw(fd),
+            }
+        }
     }
 }
 
 impl fmt::Debug for TcpStream {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.0 {}
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TcpStream")
+            .field("fd", &self.fd.as_raw())
+            .finish()
     }
 }
 
-pub struct TcpListener(Void);
+pub struct TcpListener {
+    fd: WasiFd
+}
 
 impl TcpListener {
     pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
@@ -107,49 +133,71 @@ impl TcpListener {
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn duplicate(&self) -> io::Result<TcpListener> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn only_v6(&self) -> io::Result<bool> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
+    }
+
+    pub fn fd(&self) -> &WasiFd {
+        &self.fd
+    }
+
+    pub fn into_fd(self) -> WasiFd {
+        self.fd
+    }
+}
+
+impl FromInner<u32> for TcpListener {
+    fn from_inner(fd: u32) -> TcpListener {
+        unsafe {
+            TcpListener {
+                fd: WasiFd::from_raw(fd),
+            }
+        }
     }
 }
 
 impl fmt::Debug for TcpListener {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.0 {}
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TcpListener")
+            .field("fd", &self.fd.as_raw())
+            .finish()
     }
 }
 
-pub struct UdpSocket(Void);
+pub struct UdpSocket {
+    fd: WasiFd,
+}
 
 impl UdpSocket {
     pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
@@ -157,133 +205,153 @@ impl UdpSocket {
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn recv_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn peek_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn send_to(&self, _: &[u8], _: &SocketAddr) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn duplicate(&self) -> io::Result<UdpSocket> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_broadcast(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn broadcast(&self) -> io::Result<bool> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_multicast_loop_v4(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_multicast_ttl_v4(&self, _: u32) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_multicast_loop_v6(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn multicast_loop_v6(&self) -> io::Result<bool> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn join_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr)
                          -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn join_multicast_v6(&self, _: &Ipv6Addr, _: u32)
                          -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn leave_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr)
                           -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn leave_multicast_v6(&self, _: &Ipv6Addr, _: u32)
                           -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn recv(&self, _: &mut [u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn send(&self, _: &[u8]) -> io::Result<usize> {
-        match self.0 {}
+        unsupported()
     }
 
     pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
-        match self.0 {}
+        unsupported()
+    }
+
+    pub fn fd(&self) -> &WasiFd {
+        &self.fd
+    }
+
+    pub fn into_fd(self) -> WasiFd {
+        self.fd
+    }
+}
+
+impl FromInner<u32> for UdpSocket {
+    fn from_inner(fd: u32) -> UdpSocket {
+        unsafe {
+            UdpSocket {
+                fd: WasiFd::from_raw(fd),
+            }
+        }
     }
 }
 
 impl fmt::Debug for UdpSocket {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.0 {}
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("UdpSocket")
+            .field("fd", &self.fd.as_raw())
+            .finish()
     }
 }
 
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index dcb55fb572f..f77593ed02a 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -903,7 +903,7 @@ pub const BUILTIN_ATTRIBUTES: &[(&str, AttributeType, AttributeTemplate, Attribu
     ("thread_local", Whitelisted, template!(Word), Gated(Stability::Unstable,
                                         "thread_local",
                                         "`#[thread_local]` is an experimental feature, and does \
-                                         not currently handle destructors.",
+                                         not currently handle destructors",
                                         cfg_fn!(thread_local))),
 
     ("rustc_on_unimplemented", Whitelisted, template!(List:
@@ -1438,18 +1438,34 @@ pub enum GateStrength {
     Soft,
 }
 
-pub fn emit_feature_err(sess: &ParseSess, feature: &str, span: Span, issue: GateIssue,
-                        explain: &str) {
+pub fn emit_feature_err(
+    sess: &ParseSess,
+    feature: &str,
+    span: Span,
+    issue: GateIssue,
+    explain: &str,
+) {
     feature_err(sess, feature, span, issue, explain).emit();
 }
 
-pub fn feature_err<'a>(sess: &'a ParseSess, feature: &str, span: Span, issue: GateIssue,
-                       explain: &str) -> DiagnosticBuilder<'a> {
+pub fn feature_err<'a>(
+    sess: &'a ParseSess,
+    feature: &str,
+    span: Span,
+    issue: GateIssue,
+    explain: &str,
+) -> DiagnosticBuilder<'a> {
     leveled_feature_err(sess, feature, span, issue, explain, GateStrength::Hard)
 }
 
-fn leveled_feature_err<'a>(sess: &'a ParseSess, feature: &str, span: Span, issue: GateIssue,
-                           explain: &str, level: GateStrength) -> DiagnosticBuilder<'a> {
+fn leveled_feature_err<'a>(
+    sess: &'a ParseSess,
+    feature: &str,
+    span: Span,
+    issue: GateIssue,
+    explain: &str,
+    level: GateStrength,
+) -> DiagnosticBuilder<'a> {
     let diag = &sess.span_diagnostic;
 
     let issue = match issue {
@@ -1457,23 +1473,26 @@ fn leveled_feature_err<'a>(sess: &'a ParseSess, feature: &str, span: Span, issue
         GateIssue::Library(lib) => lib,
     };
 
-    let explanation = match issue {
-        None | Some(0) => explain.to_owned(),
-        Some(n) => format!("{} (see issue #{})", explain, n)
-    };
-
     let mut err = match level {
         GateStrength::Hard => {
-            diag.struct_span_err_with_code(span, &explanation, stringify_error_code!(E0658))
+            diag.struct_span_err_with_code(span, explain, stringify_error_code!(E0658))
         }
-        GateStrength::Soft => diag.struct_span_warn(span, &explanation),
+        GateStrength::Soft => diag.struct_span_warn(span, explain),
     };
 
+    match issue {
+        None | Some(0) => {}  // We still accept `0` as a stand-in for backwards compatibility
+        Some(n) => {
+            err.note(&format!(
+                "for more information, see https://github.com/rust-lang/rust/issues/{}",
+                n,
+            ));
+        }
+    }
+
     // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
     if sess.unstable_features.is_nightly_build() {
-        err.help(&format!("add #![feature({})] to the \
-                           crate attributes to enable",
-                          feature));
+        err.help(&format!("add #![feature({})] to the crate attributes to enable", feature));
     }
 
     // If we're on stable and only emitting a "soft" warning, add a note to
@@ -1488,10 +1507,10 @@ fn leveled_feature_err<'a>(sess: &'a ParseSess, feature: &str, span: Span, issue
 }
 
 const EXPLAIN_BOX_SYNTAX: &str =
-    "box expression syntax is experimental; you can call `Box::new` instead.";
+    "box expression syntax is experimental; you can call `Box::new` instead";
 
 pub const EXPLAIN_STMT_ATTR_SYNTAX: &str =
-    "attributes on expressions are experimental.";
+    "attributes on expressions are experimental";
 
 pub const EXPLAIN_ASM: &str =
     "inline assembly is not stable enough for use and is subject to change";
@@ -1685,10 +1704,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
 
     fn visit_name(&mut self, sp: Span, name: ast::Name) {
         if !name.as_str().is_ascii() {
-            gate_feature_post!(&self,
-                               non_ascii_idents,
-                               self.context.parse_sess.source_map().def_span(sp),
-                               "non-ascii idents are not fully supported.");
+            gate_feature_post!(
+                &self,
+                non_ascii_idents,
+                self.context.parse_sess.source_map().def_span(sp),
+                "non-ascii idents are not fully supported"
+            );
         }
     }
 
diff --git a/src/libsyntax/json.rs b/src/libsyntax/json.rs
index 9acd0d099a0..838dfc62646 100644
--- a/src/libsyntax/json.rs
+++ b/src/libsyntax/json.rs
@@ -348,19 +348,17 @@ impl DiagnosticSpanLine {
     /// `span` within the line.
     fn from_span(span: Span, je: &JsonEmitter) -> Vec<DiagnosticSpanLine> {
         je.sm.span_to_lines(span)
-             .map(|lines| {
-                 let fm = &*lines.file;
-                 lines.lines
-                      .iter()
-                      .map(|line| {
-                          DiagnosticSpanLine::line_from_source_file(fm,
-                                                                line.line_index,
-                                                                line.start_col.0 + 1,
-                                                                line.end_col.0 + 1)
-                      })
-                     .collect()
-             })
-            .unwrap_or_else(|_| vec![])
+            .map(|lines| {
+                let fm = &*lines.file;
+                lines.lines
+                    .iter()
+                    .map(|line| DiagnosticSpanLine::line_from_source_file(
+                        fm,
+                        line.line_index,
+                        line.start_col.0 + 1,
+                        line.end_col.0 + 1,
+                    )).collect()
+            }).unwrap_or_else(|_| vec![])
     }
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b51b7fd1ef5..a5adb37f745 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -851,8 +851,34 @@ impl<'a> Parser<'a> {
                 }
             }
 
+            let is_semi_suggestable = expected.iter().any(|t| match t {
+                TokenType::Token(token::Semi) => true, // we expect a `;` here
+                _ => false,
+            }) && ( // a `;` would be expected before the current keyword
+                self.token.is_keyword(keywords::Break) ||
+                self.token.is_keyword(keywords::Continue) ||
+                self.token.is_keyword(keywords::For) ||
+                self.token.is_keyword(keywords::If) ||
+                self.token.is_keyword(keywords::Let) ||
+                self.token.is_keyword(keywords::Loop) ||
+                self.token.is_keyword(keywords::Match) ||
+                self.token.is_keyword(keywords::Return) ||
+                self.token.is_keyword(keywords::While)
+            );
             let cm = self.sess.source_map();
             match (cm.lookup_line(self.span.lo()), cm.lookup_line(sp.lo())) {
+                (Ok(ref a), Ok(ref b)) if a.line != b.line && is_semi_suggestable => {
+                    // The spans are in different lines, expected `;` and found `let` or `return`.
+                    // High likelihood that it is only a missing `;`.
+                    err.span_suggestion_short(
+                        label_sp,
+                        "a semicolon may be missing here",
+                        ";".to_string(),
+                        Applicability::MaybeIncorrect,
+                    );
+                    err.emit();
+                    return Ok(true);
+                }
                 (Ok(ref a), Ok(ref b)) if a.line == b.line => {
                     // When the spans are in the same line, it means that the only content between
                     // them is whitespace, point at the found token in that case:
@@ -4091,7 +4117,15 @@ impl<'a> Parser<'a> {
     {
         let (iattrs, body) = self.parse_inner_attrs_and_block()?;
         attrs.extend(iattrs);
-        Ok(self.mk_expr(span_lo.to(body.span), ExprKind::TryBlock(body), attrs))
+        if self.eat_keyword(keywords::Catch) {
+            let mut error = self.struct_span_err(self.prev_span,
+                                                 "keyword `catch` cannot follow a `try` block");
+            error.help("try using `match` on the result of the `try` block instead");
+            error.emit();
+            Err(error)
+        } else {
+            Ok(self.mk_expr(span_lo.to(body.span), ExprKind::TryBlock(body), attrs))
+        }
     }
 
     // `match` token already eaten
diff --git a/src/test/ui-fulldeps/gated-plugin.stderr b/src/test/ui-fulldeps/gated-plugin.stderr
index 37c2b443247..4f8bcda9020 100644
--- a/src/test/ui-fulldeps/gated-plugin.stderr
+++ b/src/test/ui-fulldeps/gated-plugin.stderr
@@ -1,9 +1,10 @@
-error[E0658]: compiler plugins are experimental and possibly buggy (see issue #29597)
+error[E0658]: compiler plugins are experimental and possibly buggy
   --> $DIR/gated-plugin.rs:3:1
    |
 LL | #![plugin(attr_plugin_test)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29597
    = help: add #![feature(plugin)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui-fulldeps/hash-stable-is-unstable.stderr b/src/test/ui-fulldeps/hash-stable-is-unstable.stderr
index e7007204d38..b598c86c0e0 100644
--- a/src/test/ui-fulldeps/hash-stable-is-unstable.stderr
+++ b/src/test/ui-fulldeps/hash-stable-is-unstable.stderr
@@ -2,44 +2,49 @@ error[E0601]: `main` function not found in crate `hash_stable_is_unstable`
    |
    = note: consider adding a `main` function to `$DIR/hash-stable-is-unstable.rs`
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/hash-stable-is-unstable.rs:3:1
    |
 LL | extern crate rustc_data_structures;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/hash-stable-is-unstable.rs:5:1
    |
 LL | extern crate rustc;
    | ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/hash-stable-is-unstable.rs:7:1
    |
 LL | extern crate rustc_macros;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/hash-stable-is-unstable.rs:10:5
    |
 LL | use rustc_macros::HashStable;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/hash-stable-is-unstable.rs:13:10
    |
 LL | #[derive(HashStable)]
    |          ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
 error: aborting due to 6 previous errors
diff --git a/src/test/ui/cast/cast-ptr-to-int-const.stderr b/src/test/ui/cast/cast-ptr-to-int-const.stderr
index 0d4397c2e2d..c40accfd7c4 100644
--- a/src/test/ui/cast/cast-ptr-to-int-const.stderr
+++ b/src/test/ui/cast/cast-ptr-to-int-const.stderr
@@ -1,17 +1,19 @@
-error[E0658]: casting pointers to integers in constants is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in constants is unstable
   --> $DIR/cast-ptr-to-int-const.rs:5:9
    |
 LL |         main as u32
    |         ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
-error[E0658]: casting pointers to integers in constants is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in constants is unstable
   --> $DIR/cast-ptr-to-int-const.rs:9:9
    |
 LL |         &Y as *const u32 as u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/conditional-compilation/cfg-attr-crate-2.stderr b/src/test/ui/conditional-compilation/cfg-attr-crate-2.stderr
index 8d308f0c96f..ec77789449a 100644
--- a/src/test/ui/conditional-compilation/cfg-attr-crate-2.stderr
+++ b/src/test/ui/conditional-compilation/cfg-attr-crate-2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: no_core is experimental (see issue #29639)
+error[E0658]: no_core is experimental
   --> $DIR/cfg-attr-crate-2.rs:6:21
    |
 LL | #![cfg_attr(broken, no_core)]
    |                     ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29639
    = help: add #![feature(no_core)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr b/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
index 8485459ca6b..ad5177dc9c0 100644
--- a/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
+++ b/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
@@ -1,9 +1,10 @@
-error[E0658]: no_core is experimental (see issue #29639)
+error[E0658]: no_core is experimental
   --> $DIR/cfg-attr-multi-invalid-1.rs:4:21
    |
 LL | #![cfg_attr(broken, no_core, no_std)]
    |                     ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29639
    = help: add #![feature(no_core)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr b/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
index 2a673ea8131..675997758e6 100644
--- a/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
+++ b/src/test/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: no_core is experimental (see issue #29639)
+error[E0658]: no_core is experimental
   --> $DIR/cfg-attr-multi-invalid-2.rs:4:29
    |
 LL | #![cfg_attr(broken, no_std, no_core)]
    |                             ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29639
    = help: add #![feature(no_core)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr b/src/test/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
index d0b59c3994c..ca3e3d9eff1 100644
--- a/src/test/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
+++ b/src/test/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
@@ -1,4 +1,4 @@
-error[E0658]: The attribute `unknown` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `unknown` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/cfg-attr-unknown-attribute-macro-expansion.rs:3:27
    |
 LL |         #[cfg_attr(all(), unknown)]
@@ -7,6 +7,7 @@ LL |         #[cfg_attr(all(), unknown)]
 LL | foo!();
    | ------- in this macro invocation
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/consts/const-deref-ptr.stderr b/src/test/ui/consts/const-deref-ptr.stderr
index 8de0f6c1514..23ac3b85ee6 100644
--- a/src/test/ui/consts/const-deref-ptr.stderr
+++ b/src/test/ui/consts/const-deref-ptr.stderr
@@ -1,9 +1,10 @@
-error[E0658]: dereferencing raw pointers in statics is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in statics is unstable
   --> $DIR/const-deref-ptr.rs:4:29
    |
 LL |     static C: u64 = unsafe {*(0xdeadbeef as *const u64)};
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/consts/const-eval/feature-gate-const_fn_union.stderr b/src/test/ui/consts/const-eval/feature-gate-const_fn_union.stderr
index 5a72c8205b6..069a8bfd4e7 100644
--- a/src/test/ui/consts/const-eval/feature-gate-const_fn_union.stderr
+++ b/src/test/ui/consts/const-eval/feature-gate-const_fn_union.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unions in const fn are unstable (see issue #51909)
+error[E0658]: unions in const fn are unstable
   --> $DIR/feature-gate-const_fn_union.rs:11:5
    |
 LL |     Foo { u }.i
    |     ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51909
    = help: add #![feature(const_fn_union)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr b/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr
index 08103413556..5d3e88e4e58 100644
--- a/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr
+++ b/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr
@@ -1,27 +1,30 @@
-error[E0658]: panicking in constants is unstable (see issue #51999)
+error[E0658]: panicking in constants is unstable
   --> $DIR/feature-gate-const_panic.rs:3:15
    |
 LL | const Z: () = panic!("cheese");
    |               ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51999
    = help: add #![feature(const_panic)] to the crate attributes to enable
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
-error[E0658]: panicking in constants is unstable (see issue #51999)
+error[E0658]: panicking in constants is unstable
   --> $DIR/feature-gate-const_panic.rs:9:15
    |
 LL | const X: () = unimplemented!();
    |               ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51999
    = help: add #![feature(const_panic)] to the crate attributes to enable
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
-error[E0658]: panicking in constants is unstable (see issue #51999)
+error[E0658]: panicking in constants is unstable
   --> $DIR/feature-gate-const_panic.rs:6:15
    |
 LL | const Y: () = unreachable!();
    |               ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51999
    = help: add #![feature(const_panic)] to the crate attributes to enable
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
diff --git a/src/test/ui/consts/const-eval/match-test-ptr-null.rs b/src/test/ui/consts/const-eval/match-test-ptr-null.rs
index b27b816cf50..e0af01aeef4 100644
--- a/src/test/ui/consts/const-eval/match-test-ptr-null.rs
+++ b/src/test/ui/consts/const-eval/match-test-ptr-null.rs
@@ -3,7 +3,9 @@ fn main() {
     // that pointer comparison is disallowed, not that parts of a pointer are accessed as raw
     // bytes.
     let _: [u8; 0] = [4; {
-        match &1 as *const i32 as usize { //~ ERROR casting pointers to integers in constants
+        match &1 as *const i32 as usize {
+            //~^ ERROR casting pointers to integers in constants
+            //~| NOTE for more information, see
             0 => 42, //~ ERROR constant contains unimplemented expression type
             //~^ NOTE "pointer arithmetic or comparison" needs an rfc before being allowed
             //~| ERROR evaluation of constant value failed
diff --git a/src/test/ui/consts/const-eval/match-test-ptr-null.stderr b/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
index fd5647c9af3..79e278f68ad 100644
--- a/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
+++ b/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
@@ -1,19 +1,20 @@
-error[E0658]: casting pointers to integers in constants is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in constants is unstable
   --> $DIR/match-test-ptr-null.rs:6:15
    |
 LL |         match &1 as *const i32 as usize {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
 error[E0019]: constant contains unimplemented expression type
-  --> $DIR/match-test-ptr-null.rs:7:13
+  --> $DIR/match-test-ptr-null.rs:9:13
    |
 LL |             0 => 42,
    |             ^
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/match-test-ptr-null.rs:7:13
+  --> $DIR/match-test-ptr-null.rs:9:13
    |
 LL |             0 => 42,
    |             ^ "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
diff --git a/src/test/ui/consts/min_const_fn/min_const_fn_unsafe.stderr b/src/test/ui/consts/min_const_fn/min_const_fn_unsafe.stderr
index 48c260644a7..5c1bbc6ba31 100644
--- a/src/test/ui/consts/min_const_fn/min_const_fn_unsafe.stderr
+++ b/src/test/ui/consts/min_const_fn/min_const_fn_unsafe.stderr
@@ -1,33 +1,37 @@
-error[E0658]: dereferencing raw pointers in constant functions is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in constant functions is unstable
   --> $DIR/min_const_fn_unsafe.rs:50:77
    |
 LL | const fn bad_const_fn_deref_raw(x: *mut usize) -> &'static usize { unsafe { &*x } }
    |                                                                             ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
-error[E0658]: dereferencing raw pointers in constant functions is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in constant functions is unstable
   --> $DIR/min_const_fn_unsafe.rs:53:70
    |
 LL | const unsafe fn bad_const_unsafe_deref_raw(x: *mut usize) -> usize { *x }
    |                                                                      ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
-error[E0658]: dereferencing raw pointers in constant functions is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in constant functions is unstable
   --> $DIR/min_const_fn_unsafe.rs:56:83
    |
 LL | const unsafe fn bad_const_unsafe_deref_raw_ref(x: *mut usize) -> &'static usize { &*x }
    |                                                                                   ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
-error[E0658]: unions in const fn are unstable (see issue #51909)
+error[E0658]: unions in const fn are unstable
   --> $DIR/min_const_fn_unsafe.rs:63:5
    |
 LL |     Foo { x: () }.y
    |     ^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51909
    = help: add #![feature(const_fn_union)] to the crate attributes to enable
 
 error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
diff --git a/src/test/ui/consts/projection_qualif.stderr b/src/test/ui/consts/projection_qualif.stderr
index 45679e3b962..15d332aba1f 100644
--- a/src/test/ui/consts/projection_qualif.stderr
+++ b/src/test/ui/consts/projection_qualif.stderr
@@ -10,12 +10,13 @@ error[E0019]: constant contains unimplemented expression type
 LL |         unsafe { *b = 5; }
    |                  ^^^^^^
 
-error[E0658]: dereferencing raw pointers in constants is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in constants is unstable
   --> $DIR/projection_qualif.rs:7:18
    |
 LL |         unsafe { *b = 5; }
    |                  ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/custom_attribute.stderr b/src/test/ui/custom_attribute.stderr
index 6608fb53c30..adb05e3fb2a 100644
--- a/src/test/ui/custom_attribute.stderr
+++ b/src/test/ui/custom_attribute.stderr
@@ -1,25 +1,28 @@
-error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/custom_attribute.rs:3:3
    |
 LL | #[foo]
    |   ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/custom_attribute.rs:5:7
    |
 LL |     #[foo]
    |       ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/custom_attribute.rs:7:7
    |
 LL |     #[foo]
    |       ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/error-codes/E0395.rs b/src/test/ui/error-codes/E0395.rs
index 9657bbdeadc..bbefff27d7f 100644
--- a/src/test/ui/error-codes/E0395.rs
+++ b/src/test/ui/error-codes/E0395.rs
@@ -3,6 +3,8 @@
 static FOO: i32 = 42;
 static BAR: i32 = 42;
 
-static BAZ: bool = unsafe { (&FOO as *const i32) == (&BAR as *const i32) }; //~ ERROR issue #53020
+static BAZ: bool = unsafe { (&FOO as *const i32) == (&BAR as *const i32) };
+//~^ ERROR comparing raw pointers inside static
+
 fn main() {
 }
diff --git a/src/test/ui/error-codes/E0395.stderr b/src/test/ui/error-codes/E0395.stderr
index 9d80acb515d..30a4d4815ff 100644
--- a/src/test/ui/error-codes/E0395.stderr
+++ b/src/test/ui/error-codes/E0395.stderr
@@ -1,9 +1,10 @@
-error[E0658]: comparing raw pointers inside static (see issue #53020)
+error[E0658]: comparing raw pointers inside static
   --> $DIR/E0395.rs:6:29
    |
 LL | static BAZ: bool = unsafe { (&FOO as *const i32) == (&BAR as *const i32) };
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53020
    = help: add #![feature(const_compare_raw_pointers)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/error-codes/E0396.stderr b/src/test/ui/error-codes/E0396.stderr
index 1006ff6dc54..6d2d121e91c 100644
--- a/src/test/ui/error-codes/E0396.stderr
+++ b/src/test/ui/error-codes/E0396.stderr
@@ -1,9 +1,10 @@
-error[E0658]: dereferencing raw pointers in constants is unstable (see issue #51911)
+error[E0658]: dereferencing raw pointers in constants is unstable
   --> $DIR/E0396.rs:5:28
    |
 LL | const VALUE: u8 = unsafe { *REG_ADDR };
    |                            ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51911
    = help: add #![feature(const_raw_ptr_deref)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/error-codes/E0658.stderr b/src/test/ui/error-codes/E0658.stderr
index 292c49fa84e..ff3f74addd2 100644
--- a/src/test/ui/error-codes/E0658.stderr
+++ b/src/test/ui/error-codes/E0658.stderr
@@ -1,4 +1,4 @@
-error[E0658]: repr with 128-bit type is unstable (see issue #35118)
+error[E0658]: repr with 128-bit type is unstable
   --> $DIR/E0658.rs:2:1
    |
 LL | / enum Foo {
@@ -6,6 +6,7 @@ LL | |     Bar(u64),
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35118
    = help: add #![feature(repr128)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/explore-issue-38412.stderr b/src/test/ui/explore-issue-38412.stderr
index 5e5d952bcec..eb28ad410fa 100644
--- a/src/test/ui/explore-issue-38412.stderr
+++ b/src/test/ui/explore-issue-38412.stderr
@@ -1,17 +1,19 @@
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:21:63
    |
 LL |     let Record { a_stable_pub: _, a_unstable_declared_pub: _, a_unstable_undeclared_pub: _, .. } =
    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:30:5
    |
 LL |     r.a_unstable_undeclared_pub;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
 error[E0616]: field `b_crate` of struct `pub_and_stability::Record` is private
@@ -32,12 +34,13 @@ error[E0616]: field `d_priv` of struct `pub_and_stability::Record` is private
 LL |     r.d_priv;
    |     ^^^^^^^^
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:37:5
    |
 LL |     t.2;
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
 error[E0616]: field `3` of struct `pub_and_stability::Tuple` is private
@@ -58,20 +61,22 @@ error[E0616]: field `5` of struct `pub_and_stability::Tuple` is private
 LL |     t.5;
    |     ^^^
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:44:7
    |
 LL |     r.unstable_undeclared_trait_method();
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:48:7
    |
 LL |     r.unstable_undeclared();
    |       ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
 error[E0624]: method `pub_crate` is private
@@ -92,20 +97,22 @@ error[E0624]: method `private` is private
 LL |     r.private();
    |       ^^^^^^^
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:57:7
    |
 LL |     t.unstable_undeclared_trait_method();
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'unstable_undeclared' (see issue #38412)
+error[E0658]: use of unstable library feature 'unstable_undeclared'
   --> $DIR/explore-issue-38412.rs:61:7
    |
 LL |     t.unstable_undeclared();
    |       ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38412
    = help: add #![feature(unstable_undeclared)] to the crate attributes to enable
 
 error[E0624]: method `pub_crate` is private
diff --git a/src/test/ui/feature-gate-optimize_attribute.rs b/src/test/ui/feature-gate-optimize_attribute.rs
index c1f75100141..f252a3c153d 100644
--- a/src/test/ui/feature-gate-optimize_attribute.rs
+++ b/src/test/ui/feature-gate-optimize_attribute.rs
@@ -1,17 +1,17 @@
 #![crate_type="rlib"]
-#![optimize(speed)] //~ ERROR #54882
+#![optimize(speed)] //~ ERROR #[optimize] attribute is an unstable feature
 
-#[optimize(size)] //~ ERROR #54882
+#[optimize(size)] //~ ERROR #[optimize] attribute is an unstable feature
 mod module {
 
-#[optimize(size)] //~ ERROR #54882
+#[optimize(size)] //~ ERROR #[optimize] attribute is an unstable feature
 fn size() {}
 
-#[optimize(speed)] //~ ERROR #54882
+#[optimize(speed)] //~ ERROR #[optimize] attribute is an unstable feature
 fn speed() {}
 
 #[optimize(banana)]
-//~^ ERROR #54882
+//~^ ERROR #[optimize] attribute is an unstable feature
 //~| ERROR E0722
 fn not_known() {}
 
diff --git a/src/test/ui/feature-gate-optimize_attribute.stderr b/src/test/ui/feature-gate-optimize_attribute.stderr
index 7635af6ce46..b4ba3fded15 100644
--- a/src/test/ui/feature-gate-optimize_attribute.stderr
+++ b/src/test/ui/feature-gate-optimize_attribute.stderr
@@ -1,41 +1,46 @@
-error[E0658]: #[optimize] attribute is an unstable feature (see issue #54882)
+error[E0658]: #[optimize] attribute is an unstable feature
   --> $DIR/feature-gate-optimize_attribute.rs:7:1
    |
 LL | #[optimize(size)]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54882
    = help: add #![feature(optimize_attribute)] to the crate attributes to enable
 
-error[E0658]: #[optimize] attribute is an unstable feature (see issue #54882)
+error[E0658]: #[optimize] attribute is an unstable feature
   --> $DIR/feature-gate-optimize_attribute.rs:10:1
    |
 LL | #[optimize(speed)]
    | ^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54882
    = help: add #![feature(optimize_attribute)] to the crate attributes to enable
 
-error[E0658]: #[optimize] attribute is an unstable feature (see issue #54882)
+error[E0658]: #[optimize] attribute is an unstable feature
   --> $DIR/feature-gate-optimize_attribute.rs:13:1
    |
 LL | #[optimize(banana)]
    | ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54882
    = help: add #![feature(optimize_attribute)] to the crate attributes to enable
 
-error[E0658]: #[optimize] attribute is an unstable feature (see issue #54882)
+error[E0658]: #[optimize] attribute is an unstable feature
   --> $DIR/feature-gate-optimize_attribute.rs:4:1
    |
 LL | #[optimize(size)]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54882
    = help: add #![feature(optimize_attribute)] to the crate attributes to enable
 
-error[E0658]: #[optimize] attribute is an unstable feature (see issue #54882)
+error[E0658]: #[optimize] attribute is an unstable feature
   --> $DIR/feature-gate-optimize_attribute.rs:2:1
    |
 LL | #![optimize(speed)]
    | ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54882
    = help: add #![feature(optimize_attribute)] to the crate attributes to enable
 
 error[E0722]: invalid argument
diff --git a/src/test/ui/feature-gate/feature-gate-c_variadic.stderr b/src/test/ui/feature-gate/feature-gate-c_variadic.stderr
index a876e16fdea..a1362901862 100644
--- a/src/test/ui/feature-gate/feature-gate-c_variadic.stderr
+++ b/src/test/ui/feature-gate/feature-gate-c_variadic.stderr
@@ -1,9 +1,10 @@
-error[E0658]: C-varaidic functions are unstable (see issue #44930)
+error[E0658]: C-varaidic functions are unstable
   --> $DIR/feature-gate-c_variadic.rs:3:1
    |
 LL | pub unsafe extern "C" fn test(_: i32, ap: ...) { }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44930
    = help: add #![feature(c_variadic)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gate/feature-gate-static-nobundle-2.stderr b/src/test/ui/feature-gate/feature-gate-static-nobundle-2.stderr
index 419c21901a0..4a653265f16 100644
--- a/src/test/ui/feature-gate/feature-gate-static-nobundle-2.stderr
+++ b/src/test/ui/feature-gate/feature-gate-static-nobundle-2.stderr
@@ -1,5 +1,6 @@
-error[E0658]: kind="static-nobundle" is feature gated (see issue #37403)
+error[E0658]: kind="static-nobundle" is feature gated
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/37403
    = help: add #![feature(static_nobundle)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr b/src/test/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
index 6b3c169c99d..0eb26ec8291 100644
--- a/src/test/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
+++ b/src/test/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
@@ -1,9 +1,10 @@
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi-msp430-interrupt.rs:4:1
    |
 LL | extern "msp430-interrupt" fn foo() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-abi.stderr b/src/test/ui/feature-gates/feature-gate-abi.stderr
index 7417f310921..e20ab0cb2f5 100644
--- a/src/test/ui/feature-gates/feature-gate-abi.stderr
+++ b/src/test/ui/feature-gates/feature-gate-abi.stderr
@@ -6,12 +6,13 @@ LL | extern "rust-intrinsic" fn f1() {}
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:13:1
    |
 LL | extern "platform-intrinsic" fn f2() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -22,36 +23,40 @@ LL | extern "vectorcall" fn f3() {}
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:15:1
    |
 LL | extern "rust-call" fn f4() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:16:1
    |
 LL | extern "msp430-interrupt" fn f5() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:17:1
    |
 LL | extern "ptx-kernel" fn f6() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:18:1
    |
 LL | extern "x86-interrupt" fn f7() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -62,12 +67,13 @@ LL | extern "thiscall" fn f8() {}
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:20:1
    |
 LL | extern "amdgpu-kernel" fn f9() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -78,12 +84,13 @@ LL |     extern "rust-intrinsic" fn m1();
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:25:5
    |
 LL |     extern "platform-intrinsic" fn m2();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -94,36 +101,40 @@ LL |     extern "vectorcall" fn m3();
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:27:5
    |
 LL |     extern "rust-call" fn m4();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:28:5
    |
 LL |     extern "msp430-interrupt" fn m5();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:29:5
    |
 LL |     extern "ptx-kernel" fn m6();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:30:5
    |
 LL |     extern "x86-interrupt" fn m7();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -134,12 +145,13 @@ LL |     extern "thiscall" fn m8();
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:32:5
    |
 LL |     extern "amdgpu-kernel" fn m9();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -150,12 +162,13 @@ LL |     extern "rust-intrinsic" fn dm1() {}
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:35:5
    |
 LL |     extern "platform-intrinsic" fn dm2() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -166,36 +179,40 @@ LL |     extern "vectorcall" fn dm3() {}
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:37:5
    |
 LL |     extern "rust-call" fn dm4() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:38:5
    |
 LL |     extern "msp430-interrupt" fn dm5() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:39:5
    |
 LL |     extern "ptx-kernel" fn dm6() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:40:5
    |
 LL |     extern "x86-interrupt" fn dm7() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -206,12 +223,13 @@ LL |     extern "thiscall" fn dm8() {}
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:42:5
    |
 LL |     extern "amdgpu-kernel" fn dm9() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -222,12 +240,13 @@ LL |     extern "rust-intrinsic" fn m1() {}
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:50:5
    |
 LL |     extern "platform-intrinsic" fn m2() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -238,36 +257,40 @@ LL |     extern "vectorcall" fn m3() {}
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:52:5
    |
 LL |     extern "rust-call" fn m4() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:53:5
    |
 LL |     extern "msp430-interrupt" fn m5() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:54:5
    |
 LL |     extern "ptx-kernel" fn m6() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:55:5
    |
 LL |     extern "x86-interrupt" fn m7() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -278,12 +301,13 @@ LL |     extern "thiscall" fn m8() {}
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:57:5
    |
 LL |     extern "amdgpu-kernel" fn m9() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -294,12 +318,13 @@ LL |     extern "rust-intrinsic" fn im1() {}
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:63:5
    |
 LL |     extern "platform-intrinsic" fn im2() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -310,36 +335,40 @@ LL |     extern "vectorcall" fn im3() {}
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:65:5
    |
 LL |     extern "rust-call" fn im4() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:66:5
    |
 LL |     extern "msp430-interrupt" fn im5() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:67:5
    |
 LL |     extern "ptx-kernel" fn im6() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:68:5
    |
 LL |     extern "x86-interrupt" fn im7() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -350,12 +379,13 @@ LL |     extern "thiscall" fn im8() {}
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:70:5
    |
 LL |     extern "amdgpu-kernel" fn im9() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -366,12 +396,13 @@ LL | type A1 = extern "rust-intrinsic" fn();
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:75:11
    |
 LL | type A2 = extern "platform-intrinsic" fn();
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -382,36 +413,40 @@ LL | type A3 = extern "vectorcall" fn();
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:77:11
    |
 LL | type A4 = extern "rust-call" fn();
    |           ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:78:11
    |
 LL | type A5 = extern "msp430-interrupt" fn();
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:79:11
    |
 LL | type A6 = extern "ptx-kernel" fn ();
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:80:11
    |
 LL | type A7 = extern "x86-interrupt" fn();
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -422,12 +457,13 @@ LL | type A8 = extern "thiscall" fn();
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:82:11
    |
 LL | type A9 = extern "amdgpu-kernel" fn();
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error[E0658]: intrinsics are subject to change
@@ -438,12 +474,13 @@ LL | extern "rust-intrinsic" {}
    |
    = help: add #![feature(intrinsics)] to the crate attributes to enable
 
-error[E0658]: platform intrinsics are experimental and possibly buggy (see issue #27731)
+error[E0658]: platform intrinsics are experimental and possibly buggy
   --> $DIR/feature-gate-abi.rs:86:1
    |
 LL | extern "platform-intrinsic" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(platform_intrinsics)] to the crate attributes to enable
 
 error[E0658]: vectorcall is experimental and subject to change
@@ -454,36 +491,40 @@ LL | extern "vectorcall" {}
    |
    = help: add #![feature(abi_vectorcall)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-abi.rs:88:1
    |
 LL | extern "rust-call" {}
    | ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: msp430-interrupt ABI is experimental and subject to change (see issue #38487)
+error[E0658]: msp430-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:89:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38487
    = help: add #![feature(abi_msp430_interrupt)] to the crate attributes to enable
 
-error[E0658]: PTX ABIs are experimental and subject to change (see issue #38788)
+error[E0658]: PTX ABIs are experimental and subject to change
   --> $DIR/feature-gate-abi.rs:90:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/38788
    = help: add #![feature(abi_ptx)] to the crate attributes to enable
 
-error[E0658]: x86-interrupt ABI is experimental and subject to change (see issue #40180)
+error[E0658]: x86-interrupt ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:91:1
    |
 LL | extern "x86-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/40180
    = help: add #![feature(abi_x86_interrupt)] to the crate attributes to enable
 
 error[E0658]: thiscall is experimental and subject to change
@@ -494,12 +535,13 @@ LL | extern "thiscall" {}
    |
    = help: add #![feature(abi_thiscall)] to the crate attributes to enable
 
-error[E0658]: amdgpu-kernel ABI is experimental and subject to change (see issue #51575)
+error[E0658]: amdgpu-kernel ABI is experimental and subject to change
   --> $DIR/feature-gate-abi.rs:93:1
    |
 LL | extern "amdgpu-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51575
    = help: add #![feature(abi_amdgpu_kernel)] to the crate attributes to enable
 
 error: aborting due to 63 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-alloc-error-handler.rs b/src/test/ui/feature-gates/feature-gate-alloc-error-handler.rs
index daa2bb5d6fa..df7c3ad6b3d 100644
--- a/src/test/ui/feature-gates/feature-gate-alloc-error-handler.rs
+++ b/src/test/ui/feature-gates/feature-gate-alloc-error-handler.rs
@@ -5,7 +5,7 @@
 
 use core::alloc::Layout;
 
-#[alloc_error_handler] //~ ERROR #[alloc_error_handler] is an unstable feature (see issue #51540)
+#[alloc_error_handler] //~ ERROR #[alloc_error_handler] is an unstable feature
 fn oom(info: Layout) -> ! {
     loop {}
 }
diff --git a/src/test/ui/feature-gates/feature-gate-alloc-error-handler.stderr b/src/test/ui/feature-gates/feature-gate-alloc-error-handler.stderr
index 5e64ac50c3c..cb01b5caf85 100644
--- a/src/test/ui/feature-gates/feature-gate-alloc-error-handler.stderr
+++ b/src/test/ui/feature-gates/feature-gate-alloc-error-handler.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[alloc_error_handler] is an unstable feature (see issue #51540)
+error[E0658]: #[alloc_error_handler] is an unstable feature
   --> $DIR/feature-gate-alloc-error-handler.rs:8:1
    |
 LL | #[alloc_error_handler]
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51540
    = help: add #![feature(alloc_error_handler)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-allow_fail.stderr b/src/test/ui/feature-gates/feature-gate-allow_fail.stderr
index 5de1706dd4a..af7c8de61d5 100644
--- a/src/test/ui/feature-gates/feature-gate-allow_fail.stderr
+++ b/src/test/ui/feature-gates/feature-gate-allow_fail.stderr
@@ -1,9 +1,10 @@
-error[E0658]: allow_fail attribute is currently unstable (see issue #46488)
+error[E0658]: allow_fail attribute is currently unstable
   --> $DIR/feature-gate-allow_fail.rs:3:1
    |
 LL | #[allow_fail]
    | ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/46488
    = help: add #![feature(allow_fail)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-arbitrary-self-types.stderr b/src/test/ui/feature-gates/feature-gate-arbitrary-self-types.stderr
index e1089bc345e..8d061a95676 100644
--- a/src/test/ui/feature-gates/feature-gate-arbitrary-self-types.stderr
+++ b/src/test/ui/feature-gates/feature-gate-arbitrary-self-types.stderr
@@ -1,27 +1,30 @@
-error[E0658]: `Ptr<Self>` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `Ptr<Self>` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary-self-types.rs:16:18
    |
 LL |     fn foo(self: Ptr<Self>);
    |                  ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
-error[E0658]: `Ptr<Bar>` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `Ptr<Bar>` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary-self-types.rs:22:18
    |
 LL |     fn foo(self: Ptr<Self>) {}
    |                  ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
-error[E0658]: `std::boxed::Box<Ptr<Bar>>` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `std::boxed::Box<Ptr<Bar>>` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary-self-types.rs:26:18
    |
 LL |     fn bar(self: Box<Ptr<Self>>) {}
    |                  ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
diff --git a/src/test/ui/feature-gates/feature-gate-arbitrary_self_types-raw-pointer.stderr b/src/test/ui/feature-gates/feature-gate-arbitrary_self_types-raw-pointer.stderr
index f35438f42f4..eda2403e057 100644
--- a/src/test/ui/feature-gates/feature-gate-arbitrary_self_types-raw-pointer.stderr
+++ b/src/test/ui/feature-gates/feature-gate-arbitrary_self_types-raw-pointer.stderr
@@ -1,27 +1,30 @@
-error[E0658]: `*const Self` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `*const Self` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary_self_types-raw-pointer.rs:9:18
    |
 LL |     fn bar(self: *const Self);
    |                  ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
-error[E0658]: `*const Foo` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `*const Foo` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary_self_types-raw-pointer.rs:4:18
    |
 LL |     fn foo(self: *const Self) {}
    |                  ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
-error[E0658]: `*const ()` cannot be used as the type of `self` without the `arbitrary_self_types` feature (see issue #44874)
+error[E0658]: `*const ()` cannot be used as the type of `self` without the `arbitrary_self_types` feature
   --> $DIR/feature-gate-arbitrary_self_types-raw-pointer.rs:14:18
    |
 LL |     fn bar(self: *const Self) {}
    |                  ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44874
    = help: add #![feature(arbitrary_self_types)] to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, or `self: Box<Self>`
 
diff --git a/src/test/ui/feature-gates/feature-gate-asm.stderr b/src/test/ui/feature-gates/feature-gate-asm.stderr
index 6ad0ea67313..ccaf34f0169 100644
--- a/src/test/ui/feature-gates/feature-gate-asm.stderr
+++ b/src/test/ui/feature-gates/feature-gate-asm.stderr
@@ -1,9 +1,10 @@
-error[E0658]: inline assembly is not stable enough for use and is subject to change (see issue #29722)
+error[E0658]: inline assembly is not stable enough for use and is subject to change
   --> $DIR/feature-gate-asm.rs:3:9
    |
 LL |         asm!("");
    |         ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29722
    = help: add #![feature(asm)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-asm2.stderr b/src/test/ui/feature-gates/feature-gate-asm2.stderr
index 466f2028198..cafe2be9d0b 100644
--- a/src/test/ui/feature-gates/feature-gate-asm2.stderr
+++ b/src/test/ui/feature-gates/feature-gate-asm2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: inline assembly is not stable enough for use and is subject to change (see issue #29722)
+error[E0658]: inline assembly is not stable enough for use and is subject to change
   --> $DIR/feature-gate-asm2.rs:5:26
    |
 LL |         println!("{:?}", asm!(""));
    |                          ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29722
    = help: add #![feature(asm)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-assoc-type-defaults.stderr b/src/test/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
index fe206d3dfca..16b37cf29ca 100644
--- a/src/test/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
+++ b/src/test/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
@@ -1,9 +1,10 @@
-error[E0658]: associated type defaults are unstable (see issue #29661)
+error[E0658]: associated type defaults are unstable
   --> $DIR/feature-gate-assoc-type-defaults.rs:4:5
    |
 LL |     type Bar = u8;
    |     ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29661
    = help: add #![feature(associated_type_defaults)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-async-await-2015-edition.stderr b/src/test/ui/feature-gates/feature-gate-async-await-2015-edition.stderr
index b67949b6155..77dc6a486a1 100644
--- a/src/test/ui/feature-gates/feature-gate-async-await-2015-edition.stderr
+++ b/src/test/ui/feature-gates/feature-gate-async-await-2015-edition.stderr
@@ -16,12 +16,13 @@ error[E0425]: cannot find value `async` in this scope
 LL |     let _ = async || { true };
    |             ^^^^^ not found in this scope
 
-error[E0658]: async fn is unstable (see issue #50547)
+error[E0658]: async fn is unstable
   --> $DIR/feature-gate-async-await-2015-edition.rs:5:1
    |
 LL | async fn foo() {}
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(async_await)] to the crate attributes to enable
 
 error: aborting due to 4 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-async-await.stderr b/src/test/ui/feature-gates/feature-gate-async-await.stderr
index beec28765c8..6bff254607f 100644
--- a/src/test/ui/feature-gates/feature-gate-async-await.stderr
+++ b/src/test/ui/feature-gates/feature-gate-async-await.stderr
@@ -1,25 +1,28 @@
-error[E0658]: async fn is unstable (see issue #50547)
+error[E0658]: async fn is unstable
   --> $DIR/feature-gate-async-await.rs:5:1
    |
 LL | async fn foo() {}
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(async_await)] to the crate attributes to enable
 
-error[E0658]: async blocks are unstable (see issue #50547)
+error[E0658]: async blocks are unstable
   --> $DIR/feature-gate-async-await.rs:8:13
    |
 LL |     let _ = async {};
    |             ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(async_await)] to the crate attributes to enable
 
-error[E0658]: async closures are unstable (see issue #50547)
+error[E0658]: async closures are unstable
   --> $DIR/feature-gate-async-await.rs:9:13
    |
 LL |     let _ = async || {};
    |             ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(async_await)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-box-expr.stderr b/src/test/ui/feature-gates/feature-gate-box-expr.stderr
index 7b202042878..9666793313e 100644
--- a/src/test/ui/feature-gates/feature-gate-box-expr.stderr
+++ b/src/test/ui/feature-gates/feature-gate-box-expr.stderr
@@ -1,9 +1,10 @@
-error[E0658]: box expression syntax is experimental; you can call `Box::new` instead. (see issue #49733)
+error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
   --> $DIR/feature-gate-box-expr.rs:12:13
    |
 LL |     let x = box 'c';
    |             ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49733
    = help: add #![feature(box_syntax)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-box_patterns.stderr b/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
index 39404aa39c8..765b929de8a 100644
--- a/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
+++ b/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
@@ -1,9 +1,10 @@
-error[E0658]: box pattern syntax is experimental (see issue #29641)
+error[E0658]: box pattern syntax is experimental
   --> $DIR/feature-gate-box_patterns.rs:2:9
    |
 LL |     let box x = Box::new('c');
    |         ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29641
    = help: add #![feature(box_patterns)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-box_syntax.rs b/src/test/ui/feature-gates/feature-gate-box_syntax.rs
index df0c604b2a8..778660cc0b5 100644
--- a/src/test/ui/feature-gates/feature-gate-box_syntax.rs
+++ b/src/test/ui/feature-gates/feature-gate-box_syntax.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let x = box 3;
-    //~^ ERROR box expression syntax is experimental; you can call `Box::new` instead.
+    //~^ ERROR box expression syntax is experimental; you can call `Box::new` instead
 }
diff --git a/src/test/ui/feature-gates/feature-gate-box_syntax.stderr b/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
index f144d11d89b..a9cac7686ea 100644
--- a/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
+++ b/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
@@ -1,9 +1,10 @@
-error[E0658]: box expression syntax is experimental; you can call `Box::new` instead. (see issue #49733)
+error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
   --> $DIR/feature-gate-box_syntax.rs:4:13
    |
 LL |     let x = box 3;
    |             ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49733
    = help: add #![feature(box_syntax)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs
index db1a7dad06b..827ac3af8f1 100644
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.rs
@@ -13,78 +13,78 @@ trait Sized {}
 trait Copy {}
 
 #[cfg(target_has_atomic = "8")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_u8(x: *mut u8) {
     atomic_xadd(x, 1);
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "8")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_i8(x: *mut i8) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "16")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_u16(x: *mut u16) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "16")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_i16(x: *mut i16) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "32")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_u32(x: *mut u32) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "32")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_i32(x: *mut i32) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "64")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_u64(x: *mut u64) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "64")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_i64(x: *mut i64) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "128")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_u128(x: *mut u128) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "128")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_i128(x: *mut i128) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "ptr")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_usize(x: *mut usize) {
     atomic_xadd(x, 1);
 }
 #[cfg(target_has_atomic = "ptr")]
-//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+//~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 pub unsafe fn atomic_isize(x: *mut isize) {
     atomic_xadd(x, 1);
 }
 
 fn main() {
     cfg!(target_has_atomic = "8");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
     cfg!(target_has_atomic = "16");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
     cfg!(target_has_atomic = "32");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
     cfg!(target_has_atomic = "64");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
     cfg!(target_has_atomic = "128");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
     cfg!(target_has_atomic = "ptr");
-    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+    //~^ ERROR `cfg(target_has_atomic)` is experimental and subject to change
 }
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr
index a2d5669bcdc..995528efdd3 100644
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-has-atomic.stderr
@@ -1,145 +1,163 @@
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:15:7
    |
 LL | #[cfg(target_has_atomic = "8")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:21:7
    |
 LL | #[cfg(target_has_atomic = "8")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:26:7
    |
 LL | #[cfg(target_has_atomic = "16")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:31:7
    |
 LL | #[cfg(target_has_atomic = "16")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:36:7
    |
 LL | #[cfg(target_has_atomic = "32")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:41:7
    |
 LL | #[cfg(target_has_atomic = "32")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:46:7
    |
 LL | #[cfg(target_has_atomic = "64")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:51:7
    |
 LL | #[cfg(target_has_atomic = "64")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:56:7
    |
 LL | #[cfg(target_has_atomic = "128")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:61:7
    |
 LL | #[cfg(target_has_atomic = "128")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:66:7
    |
 LL | #[cfg(target_has_atomic = "ptr")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:71:7
    |
 LL | #[cfg(target_has_atomic = "ptr")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:78:10
    |
 LL |     cfg!(target_has_atomic = "8");
    |          ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:80:10
    |
 LL |     cfg!(target_has_atomic = "16");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:82:10
    |
 LL |     cfg!(target_has_atomic = "32");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:84:10
    |
 LL |     cfg!(target_has_atomic = "64");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:86:10
    |
 LL |     cfg!(target_has_atomic = "128");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
-error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change (see issue #32976)
+error[E0658]: `cfg(target_has_atomic)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-has-atomic.rs:88:10
    |
 LL |     cfg!(target_has_atomic = "ptr");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32976
    = help: add #![feature(cfg_target_has_atomic)] to the crate attributes to enable
 
 error: aborting due to 18 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.rs b/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.rs
index 54db7500583..d44f78d4fab 100644
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.rs
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.rs
@@ -7,7 +7,7 @@ extern crate cfg_target_thread_local;
 
 extern {
     #[cfg_attr(target_thread_local, thread_local)]
-    //~^ `cfg(target_thread_local)` is experimental and subject to change (see issue #29594)
+    //~^ `cfg(target_thread_local)` is experimental and subject to change
 
     static FOO: u32;
 }
diff --git a/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr b/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
index 672fb14871a..3d24b218253 100644
--- a/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
+++ b/src/test/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `cfg(target_thread_local)` is experimental and subject to change (see issue #29594)
+error[E0658]: `cfg(target_thread_local)` is experimental and subject to change
   --> $DIR/feature-gate-cfg-target-thread-local.rs:9:16
    |
 LL |     #[cfg_attr(target_thread_local, thread_local)]
    |                ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29594
    = help: add #![feature(cfg_target_thread_local)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-concat_idents.stderr b/src/test/ui/feature-gates/feature-gate-concat_idents.stderr
index 3f4ce6d3b94..be8c727e2be 100644
--- a/src/test/ui/feature-gates/feature-gate-concat_idents.stderr
+++ b/src/test/ui/feature-gates/feature-gate-concat_idents.stderr
@@ -1,17 +1,19 @@
-error[E0658]: `concat_idents` is not stable enough for use and is subject to change (see issue #29599)
+error[E0658]: `concat_idents` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-concat_idents.rs:5:13
    |
 LL |     let a = concat_idents!(X, Y_1);
    |             ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29599
    = help: add #![feature(concat_idents)] to the crate attributes to enable
 
-error[E0658]: `concat_idents` is not stable enough for use and is subject to change (see issue #29599)
+error[E0658]: `concat_idents` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-concat_idents.rs:6:13
    |
 LL |     let b = concat_idents!(X, Y_2);
    |             ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29599
    = help: add #![feature(concat_idents)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-concat_idents2.stderr b/src/test/ui/feature-gates/feature-gate-concat_idents2.stderr
index 105b3d5cff5..1ef45115bd1 100644
--- a/src/test/ui/feature-gates/feature-gate-concat_idents2.stderr
+++ b/src/test/ui/feature-gates/feature-gate-concat_idents2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `concat_idents` is not stable enough for use and is subject to change (see issue #29599)
+error[E0658]: `concat_idents` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-concat_idents2.rs:4:5
    |
 LL |     concat_idents!(a, b);
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29599
    = help: add #![feature(concat_idents)] to the crate attributes to enable
 
 error[E0425]: cannot find value `ab` in this scope
diff --git a/src/test/ui/feature-gates/feature-gate-concat_idents3.stderr b/src/test/ui/feature-gates/feature-gate-concat_idents3.stderr
index 9568b1d8801..cb8725ab566 100644
--- a/src/test/ui/feature-gates/feature-gate-concat_idents3.stderr
+++ b/src/test/ui/feature-gates/feature-gate-concat_idents3.stderr
@@ -1,17 +1,19 @@
-error[E0658]: `concat_idents` is not stable enough for use and is subject to change (see issue #29599)
+error[E0658]: `concat_idents` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-concat_idents3.rs:7:20
    |
 LL |     assert_eq!(10, concat_idents!(X, Y_1));
    |                    ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29599
    = help: add #![feature(concat_idents)] to the crate attributes to enable
 
-error[E0658]: `concat_idents` is not stable enough for use and is subject to change (see issue #29599)
+error[E0658]: `concat_idents` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-concat_idents3.rs:8:20
    |
 LL |     assert_eq!(20, concat_idents!(X, Y_2));
    |                    ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29599
    = help: add #![feature(concat_idents)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-const_fn.stderr b/src/test/ui/feature-gates/feature-gate-const_fn.stderr
index 7f88d30acc6..0edd4eb7ab0 100644
--- a/src/test/ui/feature-gates/feature-gate-const_fn.stderr
+++ b/src/test/ui/feature-gates/feature-gate-const_fn.stderr
@@ -16,20 +16,22 @@ error[E0379]: trait fns cannot be declared const
 LL |     const fn foo() -> u32 { 0 }
    |     ^^^^^ trait fns cannot be const
 
-error[E0658]: const fn is unstable (see issue #57563)
+error[E0658]: const fn is unstable
   --> $DIR/feature-gate-const_fn.rs:6:5
    |
 LL |     const fn foo() -> u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/57563
    = help: add #![feature(const_fn)] to the crate attributes to enable
 
-error[E0658]: const fn is unstable (see issue #57563)
+error[E0658]: const fn is unstable
   --> $DIR/feature-gate-const_fn.rs:8:5
    |
 LL |     const fn bar() -> u32 { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/57563
    = help: add #![feature(const_fn)] to the crate attributes to enable
 
 error: aborting due to 5 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-const_generics.stderr b/src/test/ui/feature-gates/feature-gate-const_generics.stderr
index dce40002535..9ea04a1e204 100644
--- a/src/test/ui/feature-gates/feature-gate-const_generics.stderr
+++ b/src/test/ui/feature-gates/feature-gate-const_generics.stderr
@@ -1,17 +1,19 @@
-error[E0658]: const generics are unstable (see issue #44580)
+error[E0658]: const generics are unstable
   --> $DIR/feature-gate-const_generics.rs:1:14
    |
 LL | fn foo<const X: ()>() {}
    |              ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add #![feature(const_generics)] to the crate attributes to enable
 
-error[E0658]: const generics are unstable (see issue #44580)
+error[E0658]: const generics are unstable
   --> $DIR/feature-gate-const_generics.rs:3:18
    |
 LL | struct Foo<const X: usize>([(); X]);
    |                  ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add #![feature(const_generics)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-const_transmute.rs b/src/test/ui/feature-gates/feature-gate-const_transmute.rs
index 3c4e6de0b1e..6a5bbec77fd 100644
--- a/src/test/ui/feature-gates/feature-gate-const_transmute.rs
+++ b/src/test/ui/feature-gates/feature-gate-const_transmute.rs
@@ -4,6 +4,6 @@ use std::mem;
 struct Foo(u32);
 
 const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
-//~^ ERROR The use of std::mem::transmute() is gated in constants (see issue #53605)
+//~^ ERROR The use of std::mem::transmute() is gated in constants
 
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-const_transmute.stderr b/src/test/ui/feature-gates/feature-gate-const_transmute.stderr
index 2e07a9e7ddb..c3cd3131342 100644
--- a/src/test/ui/feature-gates/feature-gate-const_transmute.stderr
+++ b/src/test/ui/feature-gates/feature-gate-const_transmute.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The use of std::mem::transmute() is gated in constants (see issue #53605)
+error[E0658]: The use of std::mem::transmute() is gated in constants
   --> $DIR/feature-gate-const_transmute.rs:6:38
    |
 LL | const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53605
    = help: add #![feature(const_transmute)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-crate_visibility_modifier.stderr b/src/test/ui/feature-gates/feature-gate-crate_visibility_modifier.stderr
index 25b26de60ef..4e70870ae72 100644
--- a/src/test/ui/feature-gates/feature-gate-crate_visibility_modifier.stderr
+++ b/src/test/ui/feature-gates/feature-gate-crate_visibility_modifier.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `crate` visibility modifier is experimental (see issue #53120)
+error[E0658]: `crate` visibility modifier is experimental
   --> $DIR/feature-gate-crate_visibility_modifier.rs:1:1
    |
 LL | crate struct Bender {
    | ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53120
    = help: add #![feature(crate_visibility_modifier)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-custom_attribute.stderr b/src/test/ui/feature-gates/feature-gate-custom_attribute.stderr
index 8b79c752e45..9b81c38f86b 100644
--- a/src/test/ui/feature-gates/feature-gate-custom_attribute.stderr
+++ b/src/test/ui/feature-gates/feature-gate-custom_attribute.stderr
@@ -1,105 +1,118 @@
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:7:3
    |
 LL | #[fake_attr]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:8:3
    |
 LL | #[fake_attr(100)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:9:3
    |
 LL | #[fake_attr(1, 2, 3)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:10:3
    |
 LL | #[fake_attr("hello")]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:11:3
    |
 LL | #[fake_attr(name = "hello")]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:12:3
    |
 LL | #[fake_attr(1, "hi", key = 12, true, false)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:13:3
    |
 LL | #[fake_attr(key = "hello", val = 10)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:14:3
    |
 LL | #[fake_attr(key("hello"), val(10))]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:15:3
    |
 LL | #[fake_attr(enabled = true, disabled = false)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:16:3
    |
 LL | #[fake_attr(true)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:17:3
    |
 LL | #[fake_attr(pi = 3.14159)]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:18:3
    |
 LL | #[fake_attr(b"hi")]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `fake_doc` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `fake_doc` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute.rs:19:3
    |
 LL | #[fake_doc(r"doc")]
    |   ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 13 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-custom_attribute2.stderr b/src/test/ui/feature-gates/feature-gate-custom_attribute2.stderr
index 560ceda3486..8c8ac1233a0 100644
--- a/src/test/ui/feature-gates/feature-gate-custom_attribute2.stderr
+++ b/src/test/ui/feature-gates/feature-gate-custom_attribute2.stderr
@@ -1,137 +1,154 @@
-error[E0658]: The attribute `lt_struct` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_struct` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:6:13
    |
 LL | struct StLt<#[lt_struct] 'a>(&'a u32);
    |             ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_struct` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_struct` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:8:13
    |
 LL | struct StTy<#[ty_struct] I>(I);
    |             ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_enum` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_enum` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:11:11
    |
 LL | enum EnLt<#[lt_enum] 'b> { A(&'b u32), B }
    |           ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_enum` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_enum` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:13:11
    |
 LL | enum EnTy<#[ty_enum] J> { A(J), B }
    |           ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_trait` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_trait` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:16:12
    |
 LL | trait TrLt<#[lt_trait] 'c> { fn foo(&self, _: &'c [u32]) -> &'c u32; }
    |            ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_trait` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_trait` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:18:12
    |
 LL | trait TrTy<#[ty_trait] K> { fn foo(&self, _: K); }
    |            ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_type` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_type` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:21:11
    |
 LL | type TyLt<#[lt_type] 'd> = &'d u32;
    |           ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_type` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_type` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:23:11
    |
 LL | type TyTy<#[ty_type] L> = (L, );
    |           ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_inherent` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_inherent` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:26:6
    |
 LL | impl<#[lt_inherent] 'e> StLt<'e> { }
    |      ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_inherent` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_inherent` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:28:6
    |
 LL | impl<#[ty_inherent] M> StTy<M> { }
    |      ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_impl_for` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_impl_for` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:31:6
    |
 LL | impl<#[lt_impl_for] 'f> TrLt<'f> for StLt<'f> {
    |      ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_impl_for` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_impl_for` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:35:6
    |
 LL | impl<#[ty_impl_for] N> TrTy<N> for StTy<N> {
    |      ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_fn` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_fn` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:40:9
    |
 LL | fn f_lt<#[lt_fn] 'g>(_: &'g [u32]) -> &'g u32 { loop { } }
    |         ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_fn` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_fn` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:42:9
    |
 LL | fn f_ty<#[ty_fn] O>(_: O) { }
    |         ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_meth` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_meth` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:46:13
    |
 LL |     fn m_lt<#[lt_meth] 'h>(_: &'h [u32]) -> &'h u32 { loop { } }
    |             ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `ty_meth` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ty_meth` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:48:13
    |
 LL |     fn m_ty<#[ty_meth] P>(_: P) { }
    |             ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `lt_hof` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `lt_hof` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/feature-gate-custom_attribute2.rs:53:19
    |
 LL |     where Q: for <#[lt_hof] 'i> Fn(&'i [u32]) -> &'i u32
    |                   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 17 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-custom_test_frameworks.stderr b/src/test/ui/feature-gates/feature-gate-custom_test_frameworks.stderr
index bac23b3a60d..e288af54cb2 100644
--- a/src/test/ui/feature-gates/feature-gate-custom_test_frameworks.stderr
+++ b/src/test/ui/feature-gates/feature-gate-custom_test_frameworks.stderr
@@ -1,9 +1,10 @@
-error[E0658]: custom test frameworks are an unstable feature (see issue #50297)
+error[E0658]: custom test frameworks are an unstable feature
   --> $DIR/feature-gate-custom_test_frameworks.rs:1:1
    |
 LL | #![test_runner(main)]
    | ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50297
    = help: add #![feature(custom_test_frameworks)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-decl_macro.rs b/src/test/ui/feature-gates/feature-gate-decl_macro.rs
index ca0dafd0bf7..d002c5dbbd2 100644
--- a/src/test/ui/feature-gates/feature-gate-decl_macro.rs
+++ b/src/test/ui/feature-gates/feature-gate-decl_macro.rs
@@ -1,5 +1,5 @@
 #![allow(unused_macros)]
 
-macro m() {} //~ ERROR `macro` is experimental (see issue #39412)
+macro m() {} //~ ERROR `macro` is experimental
 
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-decl_macro.stderr b/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
index 2d4b622843d..808363a0048 100644
--- a/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
+++ b/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `macro` is experimental (see issue #39412)
+error[E0658]: `macro` is experimental
   --> $DIR/feature-gate-decl_macro.rs:3:1
    |
 LL | macro m() {}
    | ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/39412
    = help: add #![feature(decl_macro)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_alias.stderr b/src/test/ui/feature-gates/feature-gate-doc_alias.stderr
index c585a96adf6..be85ae4b137 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_alias.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_alias.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(alias = "...")] is experimental (see issue #50146)
+error[E0658]: #[doc(alias = "...")] is experimental
   --> $DIR/feature-gate-doc_alias.rs:1:1
    |
 LL | #[doc(alias = "foo")]
    | ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/50146
    = help: add #![feature(doc_alias)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_cfg-cfg-rustdoc.stderr b/src/test/ui/feature-gates/feature-gate-doc_cfg-cfg-rustdoc.stderr
index f018ff4a9d7..0f84a1b11f0 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_cfg-cfg-rustdoc.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_cfg-cfg-rustdoc.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `cfg(rustdoc)` is experimental and subject to change (see issue #43781)
+error[E0658]: `cfg(rustdoc)` is experimental and subject to change
   --> $DIR/feature-gate-doc_cfg-cfg-rustdoc.rs:1:7
    |
 LL | #[cfg(rustdoc)]
    |       ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/43781
    = help: add #![feature(doc_cfg)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_cfg.stderr b/src/test/ui/feature-gates/feature-gate-doc_cfg.stderr
index 2a0aa4ff3c2..9e4aa6c7a07 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_cfg.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_cfg.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(cfg(...))] is experimental (see issue #43781)
+error[E0658]: #[doc(cfg(...))] is experimental
   --> $DIR/feature-gate-doc_cfg.rs:1:1
    |
 LL | #[doc(cfg(unix))]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/43781
    = help: add #![feature(doc_cfg)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_keyword.stderr b/src/test/ui/feature-gates/feature-gate-doc_keyword.stderr
index c2cc1dceda3..6e464781721 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_keyword.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_keyword.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(keyword = "...")] is experimental (see issue #51315)
+error[E0658]: #[doc(keyword = "...")] is experimental
   --> $DIR/feature-gate-doc_keyword.rs:1:1
    |
 LL | #[doc(keyword = "match")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51315
    = help: add #![feature(doc_keyword)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_masked.stderr b/src/test/ui/feature-gates/feature-gate-doc_masked.stderr
index 77d3a6f6fb3..d778d4d994c 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_masked.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_masked.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(masked)] is experimental (see issue #44027)
+error[E0658]: #[doc(masked)] is experimental
   --> $DIR/feature-gate-doc_masked.rs:1:1
    |
 LL | #[doc(masked)]
    | ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44027
    = help: add #![feature(doc_masked)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-doc_spotlight.stderr b/src/test/ui/feature-gates/feature-gate-doc_spotlight.stderr
index 60f5c082188..2bf201f4907 100644
--- a/src/test/ui/feature-gates/feature-gate-doc_spotlight.stderr
+++ b/src/test/ui/feature-gates/feature-gate-doc_spotlight.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(spotlight)] is experimental (see issue #45040)
+error[E0658]: #[doc(spotlight)] is experimental
   --> $DIR/feature-gate-doc_spotlight.rs:1:1
    |
 LL | #[doc(spotlight)]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/45040
    = help: add #![feature(doc_spotlight)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-dropck-ugeh.stderr b/src/test/ui/feature-gates/feature-gate-dropck-ugeh.stderr
index bc62fc01b44..9c7f7b2178d 100644
--- a/src/test/ui/feature-gates/feature-gate-dropck-ugeh.stderr
+++ b/src/test/ui/feature-gates/feature-gate-dropck-ugeh.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unsafe_destructor_blind_to_params has been replaced by may_dangle and will be removed in the future (see issue #28498)
+error[E0658]: unsafe_destructor_blind_to_params has been replaced by may_dangle and will be removed in the future
   --> $DIR/feature-gate-dropck-ugeh.rs:16:5
    |
 LL |     #[unsafe_destructor_blind_to_params] // This is the UGEH attribute
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/28498
    = help: add #![feature(dropck_parametricity)] to the crate attributes to enable
 
 warning: use of deprecated attribute `dropck_parametricity`: unsafe_destructor_blind_to_params has been replaced by may_dangle and will be removed in the future. See https://github.com/rust-lang/rust/issues/34761
diff --git a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
index afb402174fb..0eb6da3b125 100644
--- a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
+++ b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
@@ -1,9 +1,10 @@
-error[E0658]: exclusive range pattern syntax is experimental (see issue #37854)
+error[E0658]: exclusive range pattern syntax is experimental
   --> $DIR/feature-gate-exclusive-range-pattern.rs:3:9
    |
 LL |         0 .. 3 => {}
    |         ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/37854
    = help: add #![feature(exclusive_range_pattern)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-existential-type.stderr b/src/test/ui/feature-gates/feature-gate-existential-type.stderr
index 6b8b850b5cc..efaf29c00da 100644
--- a/src/test/ui/feature-gates/feature-gate-existential-type.stderr
+++ b/src/test/ui/feature-gates/feature-gate-existential-type.stderr
@@ -1,17 +1,19 @@
-error[E0658]: existential types are unstable (see issue #34511)
+error[E0658]: existential types are unstable
   --> $DIR/feature-gate-existential-type.rs:3:1
    |
 LL | existential type Foo: std::fmt::Debug;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/34511
    = help: add #![feature(existential_type)] to the crate attributes to enable
 
-error[E0658]: existential types are unstable (see issue #34511)
+error[E0658]: existential types are unstable
   --> $DIR/feature-gate-existential-type.rs:11:5
    |
 LL |     existential type Baa: std::fmt::Debug;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/34511
    = help: add #![feature(existential_type)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-extern_types.stderr b/src/test/ui/feature-gates/feature-gate-extern_types.stderr
index 7035d85ec2a..18c0bae2c4b 100644
--- a/src/test/ui/feature-gates/feature-gate-extern_types.stderr
+++ b/src/test/ui/feature-gates/feature-gate-extern_types.stderr
@@ -1,9 +1,10 @@
-error[E0658]: extern types are experimental (see issue #43467)
+error[E0658]: extern types are experimental
   --> $DIR/feature-gate-extern_types.rs:2:5
    |
 LL |     type T;
    |     ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/43467
    = help: add #![feature(extern_types)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-external_doc.stderr b/src/test/ui/feature-gates/feature-gate-external_doc.stderr
index 16507bf596f..79e4f8e9b62 100644
--- a/src/test/ui/feature-gates/feature-gate-external_doc.stderr
+++ b/src/test/ui/feature-gates/feature-gate-external_doc.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[doc(include = "...")] is experimental (see issue #44732)
+error[E0658]: #[doc(include = "...")] is experimental
   --> $DIR/feature-gate-external_doc.rs:1:1
    |
 LL | #[doc(include="asdf.md")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44732
    = help: add #![feature(external_doc)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.rs b/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.rs
index d3df6e5a852..2ea60029492 100644
--- a/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.rs
+++ b/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.rs
@@ -2,6 +2,6 @@
 #![crate_type = "lib"]
 
 extern {
-    #[ffi_returns_twice] //~ ERROR the `#[ffi_returns_twice]` attribute is an experimental feature (see issue #58314)
+    #[ffi_returns_twice] //~ ERROR the `#[ffi_returns_twice]` attribute is an experimental feature
     pub fn foo();
 }
diff --git a/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.stderr b/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
index f85ce8eeeac..c28d45df7cd 100644
--- a/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
+++ b/src/test/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `#[ffi_returns_twice]` attribute is an experimental feature (see issue #58314)
+error[E0658]: the `#[ffi_returns_twice]` attribute is an experimental feature
   --> $DIR/feature-gate-ffi_returns_twice.rs:5:5
    |
 LL |     #[ffi_returns_twice]
    |     ^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/58314
    = help: add #![feature(ffi_returns_twice)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-fundamental.stderr b/src/test/ui/feature-gates/feature-gate-fundamental.stderr
index 9faf2a88a6b..265b576bc79 100644
--- a/src/test/ui/feature-gates/feature-gate-fundamental.stderr
+++ b/src/test/ui/feature-gates/feature-gate-fundamental.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `#[fundamental]` attribute is an experimental feature (see issue #29635)
+error[E0658]: the `#[fundamental]` attribute is an experimental feature
   --> $DIR/feature-gate-fundamental.rs:1:1
    |
 LL | #[fundamental]
    | ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29635
    = help: add #![feature(fundamental)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-generators.stderr b/src/test/ui/feature-gates/feature-gate-generators.stderr
index 554eeae8dec..b29fe7094f3 100644
--- a/src/test/ui/feature-gates/feature-gate-generators.stderr
+++ b/src/test/ui/feature-gates/feature-gate-generators.stderr
@@ -1,9 +1,10 @@
-error[E0658]: yield syntax is experimental (see issue #43122)
+error[E0658]: yield syntax is experimental
   --> $DIR/feature-gate-generators.rs:2:5
    |
 LL |     yield true;
    |     ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/43122
    = help: add #![feature(generators)] to the crate attributes to enable
 
 error[E0627]: yield statement outside of generator literal
diff --git a/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr b/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
index 8a207c966cd..d37dd93983c 100644
--- a/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
+++ b/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
@@ -1,57 +1,64 @@
-error[E0658]: generic associated types are unstable (see issue #44265)
+error[E0658]: generic associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:4:5
    |
 LL |     type Pointer<T>: Deref<Target = T>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: generic associated types are unstable (see issue #44265)
+error[E0658]: generic associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:6:5
    |
 LL |     type Pointer2<T>: Deref<Target = T> where T: Clone, U: Clone;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: where clauses on associated types are unstable (see issue #44265)
+error[E0658]: where clauses on associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:6:5
    |
 LL |     type Pointer2<T>: Deref<Target = T> where T: Clone, U: Clone;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: generic associated types are unstable (see issue #44265)
+error[E0658]: generic associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:14:5
    |
 LL |     type Pointer<Usize> = Box<Usize>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: generic associated types are unstable (see issue #44265)
+error[E0658]: generic associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:16:5
    |
 LL |     type Pointer2<U32> = Box<U32>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: where clauses on associated types are unstable (see issue #44265)
+error[E0658]: where clauses on associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:21:5
    |
 LL |     type Assoc where Self: Sized;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
-error[E0658]: where clauses on associated types are unstable (see issue #44265)
+error[E0658]: where clauses on associated types are unstable
   --> $DIR/feature-gate-generic_associated_types.rs:26:5
    |
 LL |     type Assoc where Self: Sized = Foo;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44265
    = help: add #![feature(generic_associated_types)] to the crate attributes to enable
 
 error: aborting due to 7 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-global_asm.stderr b/src/test/ui/feature-gates/feature-gate-global_asm.stderr
index fb9b47bd49c..7d8abac3990 100644
--- a/src/test/ui/feature-gates/feature-gate-global_asm.stderr
+++ b/src/test/ui/feature-gates/feature-gate-global_asm.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `global_asm!` is not stable enough for use and is subject to change (see issue #35119)
+error[E0658]: `global_asm!` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-global_asm.rs:1:1
    |
 LL | global_asm!("");
    | ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35119
    = help: add #![feature(global_asm)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-is_sorted.stderr b/src/test/ui/feature-gates/feature-gate-is_sorted.stderr
index 8230c1e3a38..1d5998641be 100644
--- a/src/test/ui/feature-gates/feature-gate-is_sorted.stderr
+++ b/src/test/ui/feature-gates/feature-gate-is_sorted.stderr
@@ -1,33 +1,37 @@
-error[E0658]: use of unstable library feature 'is_sorted': new API (see issue #53485)
+error[E0658]: use of unstable library feature 'is_sorted': new API
   --> $DIR/feature-gate-is_sorted.rs:3:33
    |
 LL |     assert!([1, 2, 2, 9].iter().is_sorted());
    |                                 ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53485
    = help: add #![feature(is_sorted)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'is_sorted': new API (see issue #53485)
+error[E0658]: use of unstable library feature 'is_sorted': new API
   --> $DIR/feature-gate-is_sorted.rs:5:39
    |
 LL |     assert!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n| n.abs()));
    |                                       ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53485
    = help: add #![feature(is_sorted)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'is_sorted': new API (see issue #53485)
+error[E0658]: use of unstable library feature 'is_sorted': new API
   --> $DIR/feature-gate-is_sorted.rs:9:26
    |
 LL |     assert!([1, 2, 2, 9].is_sorted());
    |                          ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53485
    = help: add #![feature(is_sorted)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'is_sorted': new API (see issue #53485)
+error[E0658]: use of unstable library feature 'is_sorted': new API
   --> $DIR/feature-gate-is_sorted.rs:11:32
    |
 LL |     assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
    |                                ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53485
    = help: add #![feature(is_sorted)] to the crate attributes to enable
 
 error: aborting due to 4 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-label_break_value.stderr b/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
index b23db3c216d..40efc4dec4b 100644
--- a/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
+++ b/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
@@ -1,9 +1,10 @@
-error[E0658]: labels on blocks are unstable (see issue #48594)
+error[E0658]: labels on blocks are unstable
   --> $DIR/feature-gate-label_break_value.rs:2:5
    |
 LL |     'a: {
    |     ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/48594
    = help: add #![feature(label_break_value)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-link_args.stderr b/src/test/ui/feature-gates/feature-gate-link_args.stderr
index c43377fe630..5267b56253f 100644
--- a/src/test/ui/feature-gates/feature-gate-link_args.stderr
+++ b/src/test/ui/feature-gates/feature-gate-link_args.stderr
@@ -1,25 +1,28 @@
-error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead (see issue #29596)
+error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead
   --> $DIR/feature-gate-link_args.rs:12:1
    |
 LL | #[link_args = "-l expected_use_case"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29596
    = help: add #![feature(link_args)] to the crate attributes to enable
 
-error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead (see issue #29596)
+error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead
   --> $DIR/feature-gate-link_args.rs:16:1
    |
 LL | #[link_args = "-l unexected_use_on_non_extern_item"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29596
    = help: add #![feature(link_args)] to the crate attributes to enable
 
-error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead (see issue #29596)
+error[E0658]: the `link_args` attribute is experimental and not portable across platforms, it is recommended to use `#[link(name = "foo")] instead
   --> $DIR/feature-gate-link_args.rs:9:1
    |
 LL | #![link_args = "-l unexpected_use_as_inner_attr_on_mod"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29596
    = help: add #![feature(link_args)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-link_cfg.stderr b/src/test/ui/feature-gates/feature-gate-link_cfg.stderr
index b5ac5fdb86a..1648245d0b8 100644
--- a/src/test/ui/feature-gates/feature-gate-link_cfg.stderr
+++ b/src/test/ui/feature-gates/feature-gate-link_cfg.stderr
@@ -1,9 +1,10 @@
-error[E0658]: is feature gated (see issue #37406)
+error[E0658]: is feature gated
   --> $DIR/feature-gate-link_cfg.rs:1:1
    |
 LL | #[link(name = "foo", cfg(foo))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/37406
    = help: add #![feature(link_cfg)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr b/src/test/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
index a6cfc99ecd2..903696dc7c2 100644
--- a/src/test/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
+++ b/src/test/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
@@ -1,9 +1,10 @@
-error[E0658]: linking to LLVM intrinsics is experimental (see issue #29602)
+error[E0658]: linking to LLVM intrinsics is experimental
   --> $DIR/feature-gate-link_llvm_intrinsics.rs:3:5
    |
 LL |     fn sqrt(x: f32) -> f32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29602
    = help: add #![feature(link_llvm_intrinsics)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-linkage.stderr b/src/test/ui/feature-gates/feature-gate-linkage.stderr
index 1399a84faf6..872c695120a 100644
--- a/src/test/ui/feature-gates/feature-gate-linkage.stderr
+++ b/src/test/ui/feature-gates/feature-gate-linkage.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `linkage` attribute is experimental and not portable across platforms (see issue #29603)
+error[E0658]: the `linkage` attribute is experimental and not portable across platforms
   --> $DIR/feature-gate-linkage.rs:2:5
    |
 LL |     #[linkage = "extern_weak"] static foo: isize;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29603
    = help: add #![feature(linkage)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-lint-reasons.stderr b/src/test/ui/feature-gates/feature-gate-lint-reasons.stderr
index 6a36d9fd5a8..9e814a20d6d 100644
--- a/src/test/ui/feature-gates/feature-gate-lint-reasons.stderr
+++ b/src/test/ui/feature-gates/feature-gate-lint-reasons.stderr
@@ -1,9 +1,10 @@
-error[E0658]: lint reasons are experimental (see issue #54503)
+error[E0658]: lint reasons are experimental
   --> $DIR/feature-gate-lint-reasons.rs:1:28
    |
 LL | #![warn(nonstandard_style, reason = "the standard should be respected")]
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54503
    = help: add #![feature(lint_reasons)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-log_syntax.stderr b/src/test/ui/feature-gates/feature-gate-log_syntax.stderr
index f29ee0b5a78..67bd48d3bed 100644
--- a/src/test/ui/feature-gates/feature-gate-log_syntax.stderr
+++ b/src/test/ui/feature-gates/feature-gate-log_syntax.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `log_syntax!` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `log_syntax!` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-log_syntax.rs:2:5
    |
 LL |     log_syntax!()
    |     ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(log_syntax)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-log_syntax2.stderr b/src/test/ui/feature-gates/feature-gate-log_syntax2.stderr
index c5a9b493728..ff0fa343c84 100644
--- a/src/test/ui/feature-gates/feature-gate-log_syntax2.stderr
+++ b/src/test/ui/feature-gates/feature-gate-log_syntax2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `log_syntax!` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `log_syntax!` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-log_syntax2.rs:4:22
    |
 LL |     println!("{:?}", log_syntax!());
    |                      ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(log_syntax)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-macros_in_extern.stderr b/src/test/ui/feature-gates/feature-gate-macros_in_extern.stderr
index affef0fe7d3..891ed81107f 100644
--- a/src/test/ui/feature-gates/feature-gate-macros_in_extern.stderr
+++ b/src/test/ui/feature-gates/feature-gate-macros_in_extern.stderr
@@ -1,25 +1,28 @@
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/feature-gate-macros_in_extern.rs:19:5
    |
 LL |     returns_isize!(rust_get_test_int);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/feature-gate-macros_in_extern.rs:21:5
    |
 LL |     takes_u32_returns_u32!(rust_dbg_extern_identity_u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/feature-gate-macros_in_extern.rs:23:5
    |
 LL |     emits_nothing!();
    |     ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-main.stderr b/src/test/ui/feature-gates/feature-gate-main.stderr
index 870cf1aa286..4d2d01b49f3 100644
--- a/src/test/ui/feature-gates/feature-gate-main.stderr
+++ b/src/test/ui/feature-gates/feature-gate-main.stderr
@@ -1,9 +1,10 @@
-error[E0658]: declaration of a nonstandard #[main] function may change over time, for now a top-level `fn main()` is required (see issue #29634)
+error[E0658]: declaration of a nonstandard #[main] function may change over time, for now a top-level `fn main()` is required
   --> $DIR/feature-gate-main.rs:2:1
    |
 LL | fn foo() {}
    | ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29634
    = help: add #![feature(main)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-marker_trait_attr.rs b/src/test/ui/feature-gates/feature-gate-marker_trait_attr.rs
index 2b1b5bba6e1..ea06c775b1a 100644
--- a/src/test/ui/feature-gates/feature-gate-marker_trait_attr.rs
+++ b/src/test/ui/feature-gates/feature-gate-marker_trait_attr.rs
@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Display};
 
 #[marker] trait ExplicitMarker {}
-//~^ ERROR marker traits is an experimental feature (see issue #29864)
+//~^ ERROR marker traits is an experimental feature
 
 impl<T: Display> ExplicitMarker for T {}
 impl<T: Debug> ExplicitMarker for T {}
diff --git a/src/test/ui/feature-gates/feature-gate-marker_trait_attr.stderr b/src/test/ui/feature-gates/feature-gate-marker_trait_attr.stderr
index e916df18b66..3ed43b52e56 100644
--- a/src/test/ui/feature-gates/feature-gate-marker_trait_attr.stderr
+++ b/src/test/ui/feature-gates/feature-gate-marker_trait_attr.stderr
@@ -1,9 +1,10 @@
-error[E0658]: marker traits is an experimental feature (see issue #29864)
+error[E0658]: marker traits is an experimental feature
   --> $DIR/feature-gate-marker_trait_attr.rs:3:1
    |
 LL | #[marker] trait ExplicitMarker {}
    | ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29864
    = help: add #![feature(marker_trait_attr)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-may-dangle.stderr b/src/test/ui/feature-gates/feature-gate-may-dangle.stderr
index 6d21147c9ee..f93be3ed4e7 100644
--- a/src/test/ui/feature-gates/feature-gate-may-dangle.stderr
+++ b/src/test/ui/feature-gates/feature-gate-may-dangle.stderr
@@ -1,9 +1,10 @@
-error[E0658]: may_dangle has unstable semantics and may be removed in the future (see issue #34761)
+error[E0658]: may_dangle has unstable semantics and may be removed in the future
   --> $DIR/feature-gate-may-dangle.rs:6:13
    |
 LL | unsafe impl<#[may_dangle] A> Drop for Pt<A> {
    |             ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/34761
    = help: add #![feature(dropck_eyepatch)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-min_const_fn.stderr b/src/test/ui/feature-gates/feature-gate-min_const_fn.stderr
index f6666b40f3e..a1c329df63a 100644
--- a/src/test/ui/feature-gates/feature-gate-min_const_fn.stderr
+++ b/src/test/ui/feature-gates/feature-gate-min_const_fn.stderr
@@ -16,20 +16,22 @@ error[E0379]: trait fns cannot be declared const
 LL |     const fn foo() -> u32 { 0 }
    |     ^^^^^ trait fns cannot be const
 
-error[E0658]: const fn is unstable (see issue #57563)
+error[E0658]: const fn is unstable
   --> $DIR/feature-gate-min_const_fn.rs:6:5
    |
 LL |     const fn foo() -> u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/57563
    = help: add #![feature(const_fn)] to the crate attributes to enable
 
-error[E0658]: const fn is unstable (see issue #57563)
+error[E0658]: const fn is unstable
   --> $DIR/feature-gate-min_const_fn.rs:8:5
    |
 LL |     const fn bar() -> u32 { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/57563
    = help: add #![feature(const_fn)] to the crate attributes to enable
 
 error: aborting due to 5 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-naked_functions.stderr b/src/test/ui/feature-gates/feature-gate-naked_functions.stderr
index 2ff5ef101e0..0ba4d551a6d 100644
--- a/src/test/ui/feature-gates/feature-gate-naked_functions.stderr
+++ b/src/test/ui/feature-gates/feature-gate-naked_functions.stderr
@@ -1,17 +1,19 @@
-error[E0658]: the `#[naked]` attribute is an experimental feature (see issue #32408)
+error[E0658]: the `#[naked]` attribute is an experimental feature
   --> $DIR/feature-gate-naked_functions.rs:1:1
    |
 LL | #[naked]
    | ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32408
    = help: add #![feature(naked_functions)] to the crate attributes to enable
 
-error[E0658]: the `#[naked]` attribute is an experimental feature (see issue #32408)
+error[E0658]: the `#[naked]` attribute is an experimental feature
   --> $DIR/feature-gate-naked_functions.rs:5:1
    |
 LL | #[naked]
    | ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32408
    = help: add #![feature(naked_functions)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-never_type.stderr b/src/test/ui/feature-gates/feature-gate-never_type.stderr
index 13166db213e..45a6e6de18b 100644
--- a/src/test/ui/feature-gates/feature-gate-never_type.stderr
+++ b/src/test/ui/feature-gates/feature-gate-never_type.stderr
@@ -1,41 +1,46 @@
-error[E0658]: The `!` type is experimental (see issue #35121)
+error[E0658]: The `!` type is experimental
   --> $DIR/feature-gate-never_type.rs:7:17
    |
 LL | type Ma = (u32, !, i32);
    |                 ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
    = help: add #![feature(never_type)] to the crate attributes to enable
 
-error[E0658]: The `!` type is experimental (see issue #35121)
+error[E0658]: The `!` type is experimental
   --> $DIR/feature-gate-never_type.rs:8:20
    |
 LL | type Meeshka = Vec<!>;
    |                    ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
    = help: add #![feature(never_type)] to the crate attributes to enable
 
-error[E0658]: The `!` type is experimental (see issue #35121)
+error[E0658]: The `!` type is experimental
   --> $DIR/feature-gate-never_type.rs:9:24
    |
 LL | type Mow = &'static fn(!) -> !;
    |                        ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
    = help: add #![feature(never_type)] to the crate attributes to enable
 
-error[E0658]: The `!` type is experimental (see issue #35121)
+error[E0658]: The `!` type is experimental
   --> $DIR/feature-gate-never_type.rs:10:27
    |
 LL | type Skwoz = &'static mut !;
    |                           ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
    = help: add #![feature(never_type)] to the crate attributes to enable
 
-error[E0658]: The `!` type is experimental (see issue #35121)
+error[E0658]: The `!` type is experimental
   --> $DIR/feature-gate-never_type.rs:13:16
    |
 LL |     type Wub = !;
    |                ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
    = help: add #![feature(never_type)] to the crate attributes to enable
 
 error: aborting due to 5 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-no-debug.stderr b/src/test/ui/feature-gates/feature-gate-no-debug.stderr
index 1ee2ec3c881..a58a75b70c5 100644
--- a/src/test/ui/feature-gates/feature-gate-no-debug.stderr
+++ b/src/test/ui/feature-gates/feature-gate-no-debug.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `#[no_debug]` attribute was an experimental feature that has been deprecated due to lack of demand (see issue #29721)
+error[E0658]: the `#[no_debug]` attribute was an experimental feature that has been deprecated due to lack of demand
   --> $DIR/feature-gate-no-debug.rs:3:1
    |
 LL | #[no_debug]
    | ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29721
    = help: add #![feature(no_debug)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-no_core.stderr b/src/test/ui/feature-gates/feature-gate-no_core.stderr
index 279f2198a80..e2f0fd68a7c 100644
--- a/src/test/ui/feature-gates/feature-gate-no_core.stderr
+++ b/src/test/ui/feature-gates/feature-gate-no_core.stderr
@@ -1,9 +1,10 @@
-error[E0658]: no_core is experimental (see issue #29639)
+error[E0658]: no_core is experimental
   --> $DIR/feature-gate-no_core.rs:3:1
    |
 LL | #![no_core]
    | ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29639
    = help: add #![feature(no_core)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-non_ascii_idents.stderr b/src/test/ui/feature-gates/feature-gate-non_ascii_idents.stderr
index 5e4c4649d01..1d78b87a3e0 100644
--- a/src/test/ui/feature-gates/feature-gate-non_ascii_idents.stderr
+++ b/src/test/ui/feature-gates/feature-gate-non_ascii_idents.stderr
@@ -1,105 +1,118 @@
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:1:22
    |
 LL | extern crate core as bäz;
    |                      ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:3:5
    |
 LL | use föö::bar;
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:5:5
    |
 LL | mod föö {
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:9:4
    |
 LL | fn bär(
    |    ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:10:5
    |
 LL |     bäz: isize
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:12:9
    |
 LL |     let _ö: isize;
    |         ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:15:10
    |
 LL |         (_ä, _) => {}
    |          ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:19:8
    |
 LL | struct Föö {
    |        ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:20:5
    |
 LL |     föö: isize
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:23:6
    |
 LL | enum Bär {
    |      ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:24:5
    |
 LL |     Bäz {
    |     ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:25:9
    |
 LL |         qüx: isize
    |         ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/feature-gate-non_ascii_idents.rs:30:8
    |
 LL |     fn qüx();
    |        ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
 error: aborting due to 13 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-non_exhaustive.rs b/src/test/ui/feature-gates/feature-gate-non_exhaustive.rs
index b3e2e3d95f5..aca214d1935 100644
--- a/src/test/ui/feature-gates/feature-gate-non_exhaustive.rs
+++ b/src/test/ui/feature-gates/feature-gate-non_exhaustive.rs
@@ -1,6 +1,6 @@
 //#![feature(non_exhaustive)]
 
-#[non_exhaustive] //~ERROR non exhaustive is an experimental feature (see issue #44109)
+#[non_exhaustive] //~ERROR non exhaustive is an experimental feature
 pub enum NonExhaustiveEnum {
     Unit,
     Tuple(u32),
diff --git a/src/test/ui/feature-gates/feature-gate-non_exhaustive.stderr b/src/test/ui/feature-gates/feature-gate-non_exhaustive.stderr
index 524f77902f6..fdb1ffb0a9b 100644
--- a/src/test/ui/feature-gates/feature-gate-non_exhaustive.stderr
+++ b/src/test/ui/feature-gates/feature-gate-non_exhaustive.stderr
@@ -1,9 +1,10 @@
-error[E0658]: non exhaustive is an experimental feature (see issue #44109)
+error[E0658]: non exhaustive is an experimental feature
   --> $DIR/feature-gate-non_exhaustive.rs:3:1
    |
 LL | #[non_exhaustive]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44109
    = help: add #![feature(non_exhaustive)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-on-unimplemented.stderr b/src/test/ui/feature-gates/feature-gate-on-unimplemented.stderr
index 32bfb20d5ed..044a9a398d6 100644
--- a/src/test/ui/feature-gates/feature-gate-on-unimplemented.stderr
+++ b/src/test/ui/feature-gates/feature-gate-on-unimplemented.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `#[rustc_on_unimplemented]` attribute is an experimental feature (see issue #29628)
+error[E0658]: the `#[rustc_on_unimplemented]` attribute is an experimental feature
   --> $DIR/feature-gate-on-unimplemented.rs:4:1
    |
 LL | #[rustc_on_unimplemented = "test error `{Self}` with `{Bar}`"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29628
    = help: add #![feature(on_unimplemented)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-optin-builtin-traits.stderr b/src/test/ui/feature-gates/feature-gate-optin-builtin-traits.stderr
index e5d0a8681fb..baad1627d9c 100644
--- a/src/test/ui/feature-gates/feature-gate-optin-builtin-traits.stderr
+++ b/src/test/ui/feature-gates/feature-gate-optin-builtin-traits.stderr
@@ -1,17 +1,19 @@
-error[E0658]: auto traits are experimental and possibly buggy (see issue #13231)
+error[E0658]: auto traits are experimental and possibly buggy
   --> $DIR/feature-gate-optin-builtin-traits.rs:6:1
    |
 LL | auto trait AutoDummyTrait {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/13231
    = help: add #![feature(optin_builtin_traits)] to the crate attributes to enable
 
-error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now (see issue #13231)
+error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now
   --> $DIR/feature-gate-optin-builtin-traits.rs:9:1
    |
 LL | impl !AutoDummyTrait for DummyStruct {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/13231
    = help: add #![feature(optin_builtin_traits)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-plugin.stderr b/src/test/ui/feature-gates/feature-gate-plugin.stderr
index 0feebb6f0e0..5ac41201888 100644
--- a/src/test/ui/feature-gates/feature-gate-plugin.stderr
+++ b/src/test/ui/feature-gates/feature-gate-plugin.stderr
@@ -1,9 +1,10 @@
-error[E0658]: compiler plugins are experimental and possibly buggy (see issue #29597)
+error[E0658]: compiler plugins are experimental and possibly buggy
   --> $DIR/feature-gate-plugin.rs:3:1
    |
 LL | #![plugin(foo)]
    | ^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29597
    = help: add #![feature(plugin)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-plugin_registrar.stderr b/src/test/ui/feature-gates/feature-gate-plugin_registrar.stderr
index 6464d4087be..941a6c49d15 100644
--- a/src/test/ui/feature-gates/feature-gate-plugin_registrar.stderr
+++ b/src/test/ui/feature-gates/feature-gate-plugin_registrar.stderr
@@ -1,9 +1,10 @@
-error[E0658]: compiler plugins are experimental and possibly buggy (see issue #29597)
+error[E0658]: compiler plugins are experimental and possibly buggy
   --> $DIR/feature-gate-plugin_registrar.rs:6:1
    |
 LL | pub fn registrar() {}
    | ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29597
    = help: add #![feature(plugin_registrar)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-repr-simd.stderr b/src/test/ui/feature-gates/feature-gate-repr-simd.stderr
index c47ce70eaae..056bfdd85d1 100644
--- a/src/test/ui/feature-gates/feature-gate-repr-simd.stderr
+++ b/src/test/ui/feature-gates/feature-gate-repr-simd.stderr
@@ -1,17 +1,19 @@
-error[E0658]: SIMD types are experimental and possibly buggy (see issue #27731)
+error[E0658]: SIMD types are experimental and possibly buggy
   --> $DIR/feature-gate-repr-simd.rs:1:1
    |
 LL | #[repr(simd)]
    | ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(repr_simd)] to the crate attributes to enable
 
-error[E0658]: SIMD types are experimental and possibly buggy (see issue #27731)
+error[E0658]: SIMD types are experimental and possibly buggy
   --> $DIR/feature-gate-repr-simd.rs:5:1
    |
 LL | #[repr(simd)]
    | ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(repr_simd)] to the crate attributes to enable
 
 warning[E0566]: conflicting representation hints
diff --git a/src/test/ui/feature-gates/feature-gate-repr128.stderr b/src/test/ui/feature-gates/feature-gate-repr128.stderr
index a2fd6593599..30433447a2b 100644
--- a/src/test/ui/feature-gates/feature-gate-repr128.stderr
+++ b/src/test/ui/feature-gates/feature-gate-repr128.stderr
@@ -1,4 +1,4 @@
-error[E0658]: repr with 128-bit type is unstable (see issue #35118)
+error[E0658]: repr with 128-bit type is unstable
   --> $DIR/feature-gate-repr128.rs:2:1
    |
 LL | / enum A {
@@ -6,6 +6,7 @@ LL | |     A(u64)
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/35118
    = help: add #![feature(repr128)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs b/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs
index f8e68a9de01..8b68caa6f5b 100644
--- a/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs
+++ b/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs
@@ -1,7 +1,7 @@
 #[repr(align(16))]
 struct Foo(u64);
 
-#[repr(align(8))] //~ ERROR `#[repr(align(x))]` on enums is experimental (see issue #57996)
+#[repr(align(8))] //~ ERROR `#[repr(align(x))]` on enums is experimental
 enum Bar {
     Foo { foo: Foo },
     Baz,
diff --git a/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr b/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr
index ae4066ceb80..36924f4c167 100644
--- a/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr
+++ b/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `#[repr(align(x))]` on enums is experimental (see issue #57996)
+error[E0658]: `#[repr(align(x))]` on enums is experimental
   --> $DIR/feature-gate-repr_align_enum.rs:4:1
    |
 LL | #[repr(align(8))]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/57996
    = help: add #![feature(repr_align_enum)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-rustc-attrs-1.stderr b/src/test/ui/feature-gates/feature-gate-rustc-attrs-1.stderr
index 73cd28fe749..882feb87f42 100644
--- a/src/test/ui/feature-gates/feature-gate-rustc-attrs-1.stderr
+++ b/src/test/ui/feature-gates/feature-gate-rustc-attrs-1.stderr
@@ -1,17 +1,19 @@
-error[E0658]: the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
+error[E0658]: the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable
   --> $DIR/feature-gate-rustc-attrs-1.rs:5:1
    |
 LL | #[rustc_variance]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
-error[E0658]: the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
+error[E0658]: the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable
   --> $DIR/feature-gate-rustc-attrs-1.rs:6:1
    |
 LL | #[rustc_error]
    | ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr b/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr
index 40e6d6d9256..3c823c8d4e2 100644
--- a/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr
+++ b/src/test/ui/feature-gates/feature-gate-rustc-attrs.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics (see issue #29642)
+error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics
   --> $DIR/feature-gate-rustc-attrs.rs:3:3
    |
 LL | #[rustc_foo]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-simd.stderr b/src/test/ui/feature-gates/feature-gate-simd.stderr
index b37f138fbb5..1686a8530fe 100644
--- a/src/test/ui/feature-gates/feature-gate-simd.stderr
+++ b/src/test/ui/feature-gates/feature-gate-simd.stderr
@@ -1,9 +1,10 @@
-error[E0658]: SIMD types are experimental and possibly buggy (see issue #27731)
+error[E0658]: SIMD types are experimental and possibly buggy
   --> $DIR/feature-gate-simd.rs:3:1
    |
 LL | #[repr(simd)]
    | ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(repr_simd)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-slice-patterns.stderr b/src/test/ui/feature-gates/feature-gate-slice-patterns.stderr
index 58eb57516eb..fe3c1e0afdd 100644
--- a/src/test/ui/feature-gates/feature-gate-slice-patterns.stderr
+++ b/src/test/ui/feature-gates/feature-gate-slice-patterns.stderr
@@ -1,49 +1,55 @@
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:6:16
    |
 LL |         [1, 2, ..] => {}
    |                ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:7:13
    |
 LL |         [1, .., 5] => {}
    |             ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:8:10
    |
 LL |         [.., 4, 5] => {}
    |          ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:13:11
    |
 LL |         [ xs.., 4, 5 ] => {}
    |           ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:14:14
    |
 LL |         [ 1, xs.., 5 ] => {}
    |              ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
-error[E0658]: syntax for subslices in slice patterns is not yet stabilized (see issue #23121)
+error[E0658]: syntax for subslices in slice patterns is not yet stabilized
   --> $DIR/feature-gate-slice-patterns.rs:15:17
    |
 LL |         [ 1, 2, xs.. ] => {}
    |                 ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23121
    = help: add #![feature(slice_patterns)] to the crate attributes to enable
 
 error: aborting due to 6 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-start.stderr b/src/test/ui/feature-gates/feature-gate-start.stderr
index d39e5f35555..fbe64ea130d 100644
--- a/src/test/ui/feature-gates/feature-gate-start.stderr
+++ b/src/test/ui/feature-gates/feature-gate-start.stderr
@@ -1,9 +1,10 @@
-error[E0658]: a #[start] function is an experimental feature whose signature may change over time (see issue #29633)
+error[E0658]: a #[start] function is an experimental feature whose signature may change over time
   --> $DIR/feature-gate-start.rs:2:1
    |
 LL | fn foo(_: isize, _: *const *const u8) -> isize { 0 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29633
    = help: add #![feature(start)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-static-nobundle.stderr b/src/test/ui/feature-gates/feature-gate-static-nobundle.stderr
index 2e80275f3f7..7d5ed74abd1 100644
--- a/src/test/ui/feature-gates/feature-gate-static-nobundle.stderr
+++ b/src/test/ui/feature-gates/feature-gate-static-nobundle.stderr
@@ -1,9 +1,10 @@
-error[E0658]: kind="static-nobundle" is feature gated (see issue #37403)
+error[E0658]: kind="static-nobundle" is feature gated
   --> $DIR/feature-gate-static-nobundle.rs:1:1
    |
 LL | #[link(name="foo", kind="static-nobundle")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/37403
    = help: add #![feature(static_nobundle)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.rs b/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.rs
index 3e5b6260d74..f213e8933bf 100644
--- a/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.rs
+++ b/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.rs
@@ -1,4 +1,4 @@
 const X: i32 = #[allow(dead_code)] 8;
-//~^ ERROR attributes on expressions are experimental. (see issue #15701)
+//~^ ERROR attributes on expressions are experimental
 
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr b/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
index 4318edd9230..bbf0f66ca54 100644
--- a/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
+++ b/src/test/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
@@ -1,9 +1,10 @@
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/feature-gate-stmt_expr_attributes.rs:1:16
    |
 LL | const X: i32 = #[allow(dead_code)] 8;
    |                ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-thread_local.stderr b/src/test/ui/feature-gates/feature-gate-thread_local.stderr
index 38064a6bc94..95334d23d51 100644
--- a/src/test/ui/feature-gates/feature-gate-thread_local.stderr
+++ b/src/test/ui/feature-gates/feature-gate-thread_local.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `#[thread_local]` is an experimental feature, and does not currently handle destructors. (see issue #29594)
+error[E0658]: `#[thread_local]` is an experimental feature, and does not currently handle destructors
   --> $DIR/feature-gate-thread_local.rs:8:1
    |
 LL | #[thread_local]
    | ^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29594
    = help: add #![feature(thread_local)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-trace_macros.stderr b/src/test/ui/feature-gates/feature-gate-trace_macros.stderr
index ee22bd25091..bcce31d873b 100644
--- a/src/test/ui/feature-gates/feature-gate-trace_macros.stderr
+++ b/src/test/ui/feature-gates/feature-gate-trace_macros.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `trace_macros` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `trace_macros` is not stable enough for use and is subject to change
   --> $DIR/feature-gate-trace_macros.rs:2:5
    |
 LL |     trace_macros!(true);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(trace_macros)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-trait-alias.stderr b/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
index bb833c4e732..1a9718a6ce4 100644
--- a/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
+++ b/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
@@ -1,9 +1,10 @@
-error[E0658]: trait aliases are experimental (see issue #41517)
+error[E0658]: trait aliases are experimental
   --> $DIR/feature-gate-trait-alias.rs:1:1
    |
 LL | trait Foo = Default;
    | ^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/41517
    = help: add #![feature(trait_alias)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-try_blocks.stderr b/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
index 74ad0e70c96..cb72b067333 100644
--- a/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
+++ b/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
@@ -1,4 +1,4 @@
-error[E0658]: `try` expression is experimental (see issue #31436)
+error[E0658]: `try` expression is experimental
   --> $DIR/feature-gate-try_blocks.rs:4:33
    |
 LL |       let try_result: Option<_> = try {
@@ -8,6 +8,7 @@ LL | |         x
 LL | |     };
    | |_____^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/31436
    = help: add #![feature(try_blocks)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-try_reserve.stderr b/src/test/ui/feature-gates/feature-gate-try_reserve.stderr
index 61a3249c2ab..f1d82d94a52 100644
--- a/src/test/ui/feature-gates/feature-gate-try_reserve.stderr
+++ b/src/test/ui/feature-gates/feature-gate-try_reserve.stderr
@@ -1,9 +1,10 @@
-error[E0658]: use of unstable library feature 'try_reserve': new API (see issue #48043)
+error[E0658]: use of unstable library feature 'try_reserve': new API
   --> $DIR/feature-gate-try_reserve.rs:3:7
    |
 LL |     v.try_reserve(10);
    |       ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/48043
    = help: add #![feature(try_reserve)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-type_ascription.stderr b/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
index 13dbb602967..0e4e25882c8 100644
--- a/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
+++ b/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
@@ -1,9 +1,10 @@
-error[E0658]: type ascription is experimental (see issue #23416)
+error[E0658]: type ascription is experimental
   --> $DIR/feature-gate-type_ascription.rs:4:13
    |
 LL |     let a = 10: u8;
    |             ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/23416
    = help: add #![feature(type_ascription)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr b/src/test/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
index 865b87e7dd5..5fbaf8dd0ba 100644
--- a/src/test/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unboxed-closures-manual-impls.stderr
@@ -1,41 +1,46 @@
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:11:5
    |
 LL |     extern "rust-call" fn call(self, args: ()) -> () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:17:5
    |
 LL |     extern "rust-call" fn call_once(self, args: ()) -> () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:23:5
    |
 LL |     extern "rust-call" fn call_mut(&self, args: ()) -> () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:29:5
    |
 LL |     extern "rust-call" fn call_once(&self, args: ()) -> () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:9:6
    |
 LL | impl Fn<()> for Foo {
    |      ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error[E0229]: associated type bindings are not allowed here
@@ -44,20 +49,22 @@ error[E0229]: associated type bindings are not allowed here
 LL | impl FnOnce() for Foo1 {
    |            ^^ associated type not allowed here
 
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:21:6
    |
 LL | impl FnMut<()> for Bar {
    |      ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/feature-gate-unboxed-closures-manual-impls.rs:27:6
    |
 LL | impl FnOnce<()> for Baz {
    |      ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error: aborting due to 8 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-unboxed-closures-method-calls.stderr b/src/test/ui/feature-gates/feature-gate-unboxed-closures-method-calls.stderr
index 519f6528323..164368cd8ef 100644
--- a/src/test/ui/feature-gates/feature-gate-unboxed-closures-method-calls.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unboxed-closures-method-calls.stderr
@@ -1,25 +1,28 @@
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-method-calls.rs:4:7
    |
 LL |     f.call(());
    |       ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-method-calls.rs:5:7
    |
 LL |     f.call_mut(());
    |       ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-method-calls.rs:6:7
    |
 LL |     f.call_once(());
    |       ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-unboxed-closures-ufcs-calls.stderr b/src/test/ui/feature-gates/feature-gate-unboxed-closures-ufcs-calls.stderr
index a49a8b4cdb2..ff2629fe421 100644
--- a/src/test/ui/feature-gates/feature-gate-unboxed-closures-ufcs-calls.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unboxed-closures-ufcs-calls.stderr
@@ -1,25 +1,28 @@
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-ufcs-calls.rs:4:5
    |
 LL |     Fn::call(&f, ());
    |     ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-ufcs-calls.rs:5:5
    |
 LL |     FnMut::call_mut(&mut f, ());
    |     ^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'fn_traits' (see issue #29625)
+error[E0658]: use of unstable library feature 'fn_traits'
   --> $DIR/feature-gate-unboxed-closures-ufcs-calls.rs:6:5
    |
 LL |     FnOnce::call_once(f, ());
    |     ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(fn_traits)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-unboxed-closures.rs b/src/test/ui/feature-gates/feature-gate-unboxed-closures.rs
index c3f5c99dcb4..b8d3aa4a141 100644
--- a/src/test/ui/feature-gates/feature-gate-unboxed-closures.rs
+++ b/src/test/ui/feature-gates/feature-gate-unboxed-closures.rs
@@ -9,7 +9,7 @@ impl FnOnce<(u32, u32)> for Test {
     extern "rust-call" fn call_once(self, (a, b): (u32, u32)) -> u32 {
         a + b
     }
-    //~^^^ ERROR rust-call ABI is subject to change (see issue #29625)
+    //~^^^ ERROR rust-call ABI is subject to change
 }
 
 fn main() {
diff --git a/src/test/ui/feature-gates/feature-gate-unboxed-closures.stderr b/src/test/ui/feature-gates/feature-gate-unboxed-closures.stderr
index e7b1fc589bb..872a593f3e4 100644
--- a/src/test/ui/feature-gates/feature-gate-unboxed-closures.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unboxed-closures.stderr
@@ -1,4 +1,4 @@
-error[E0658]: rust-call ABI is subject to change (see issue #29625)
+error[E0658]: rust-call ABI is subject to change
   --> $DIR/feature-gate-unboxed-closures.rs:9:5
    |
 LL | /     extern "rust-call" fn call_once(self, (a, b): (u32, u32)) -> u32 {
@@ -6,14 +6,16 @@ LL | |         a + b
 LL | |     }
    | |_____^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/feature-gate-unboxed-closures.rs:5:6
    |
 LL | impl FnOnce<(u32, u32)> for Test {
    |      ^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-underscore_const_names.stderr b/src/test/ui/feature-gates/feature-gate-underscore_const_names.stderr
index ef93bb97ab4..8d925424d8c 100644
--- a/src/test/ui/feature-gates/feature-gate-underscore_const_names.stderr
+++ b/src/test/ui/feature-gates/feature-gate-underscore_const_names.stderr
@@ -1,4 +1,4 @@
-error[E0658]: naming constants with `_` is unstable (see issue #54912)
+error[E0658]: naming constants with `_` is unstable
   --> $DIR/feature-gate-underscore_const_names.rs:6:1
    |
 LL | / const _ : () = {
@@ -10,6 +10,7 @@ LL | |     ()
 LL | | };
    | |__^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54912
    = help: add #![feature(underscore_const_names)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr b/src/test/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
index c2f5df48fed..669e87ceada 100644
--- a/src/test/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unsized tuple coercion is not stable enough for use and is subject to change (see issue #42877)
+error[E0658]: unsized tuple coercion is not stable enough for use and is subject to change
   --> $DIR/feature-gate-unsized_tuple_coercion.rs:2:24
    |
 LL |     let _ : &(Send,) = &((),);
    |                        ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/42877
    = help: add #![feature(unsized_tuple_coercion)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/feature-gate-untagged_unions.stderr b/src/test/ui/feature-gates/feature-gate-untagged_unions.stderr
index 6faa0528dc7..5df3a1d699f 100644
--- a/src/test/ui/feature-gates/feature-gate-untagged_unions.stderr
+++ b/src/test/ui/feature-gates/feature-gate-untagged_unions.stderr
@@ -1,4 +1,4 @@
-error[E0658]: unions with non-`Copy` fields are unstable (see issue #32836)
+error[E0658]: unions with non-`Copy` fields are unstable
   --> $DIR/feature-gate-untagged_unions.rs:9:1
    |
 LL | / union U3 {
@@ -6,9 +6,10 @@ LL | |     a: String,
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32836
    = help: add #![feature(untagged_unions)] to the crate attributes to enable
 
-error[E0658]: unions with non-`Copy` fields are unstable (see issue #32836)
+error[E0658]: unions with non-`Copy` fields are unstable
   --> $DIR/feature-gate-untagged_unions.rs:13:1
    |
 LL | / union U4<T> {
@@ -16,9 +17,10 @@ LL | |     a: T,
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32836
    = help: add #![feature(untagged_unions)] to the crate attributes to enable
 
-error[E0658]: unions with `Drop` implementations are unstable (see issue #32836)
+error[E0658]: unions with `Drop` implementations are unstable
   --> $DIR/feature-gate-untagged_unions.rs:17:1
    |
 LL | / union U5 {
@@ -26,6 +28,7 @@ LL | |     a: u8,
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32836
    = help: add #![feature(untagged_unions)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-unwind-attributes.stderr b/src/test/ui/feature-gates/feature-gate-unwind-attributes.stderr
index 149ce9e4f82..bb55013d638 100644
--- a/src/test/ui/feature-gates/feature-gate-unwind-attributes.stderr
+++ b/src/test/ui/feature-gates/feature-gate-unwind-attributes.stderr
@@ -1,9 +1,10 @@
-error[E0658]: #[unwind] is experimental (see issue #58760)
+error[E0658]: #[unwind] is experimental
   --> $DIR/feature-gate-unwind-attributes.rs:11:5
    |
 LL |     #[unwind(allowed)]
    |     ^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/58760
    = help: add #![feature(unwind_attributes)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/feature-gates/underscore_const_names_feature_gate.stderr b/src/test/ui/feature-gates/underscore_const_names_feature_gate.stderr
index 83b3017a4cd..0931145a6e2 100644
--- a/src/test/ui/feature-gates/underscore_const_names_feature_gate.stderr
+++ b/src/test/ui/feature-gates/underscore_const_names_feature_gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: naming constants with `_` is unstable (see issue #54912)
+error[E0658]: naming constants with `_` is unstable
   --> $DIR/underscore_const_names_feature_gate.rs:1:1
    |
 LL | const _: () = ();
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54912
    = help: add #![feature(underscore_const_names)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/imports/local-modularized-tricky-fail-2.stderr b/src/test/ui/imports/local-modularized-tricky-fail-2.stderr
index a26f0cbec72..70d197994f3 100644
--- a/src/test/ui/imports/local-modularized-tricky-fail-2.stderr
+++ b/src/test/ui/imports/local-modularized-tricky-fail-2.stderr
@@ -1,4 +1,4 @@
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/local-modularized-tricky-fail-2.rs:20:32
    |
 LL | exported!();
@@ -7,9 +7,10 @@ LL | exported!();
 LL |                 () => ( struct Б; )
    |                                ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/local-modularized-tricky-fail-2.rs:36:24
    |
 LL |     panic!();
@@ -18,9 +19,10 @@ LL |     panic!();
 LL |         () => ( struct Г; )
    |                        ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/local-modularized-tricky-fail-2.rs:46:24
    |
 LL | include!();
@@ -29,6 +31,7 @@ LL | include!();
 LL |         () => ( struct Д; )
    |                        ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/inference/inference_unstable_forced.stderr b/src/test/ui/inference/inference_unstable_forced.stderr
index 067bf44bda8..83e27aaf2f8 100644
--- a/src/test/ui/inference/inference_unstable_forced.stderr
+++ b/src/test/ui/inference/inference_unstable_forced.stderr
@@ -1,9 +1,10 @@
-error[E0658]: use of unstable library feature 'ipu_flatten' (see issue #99999)
+error[E0658]: use of unstable library feature 'ipu_flatten'
   --> $DIR/inference_unstable_forced.rs:11:20
    |
 LL |     assert_eq!('x'.ipu_flatten(), 0);
    |                    ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/99999
    = help: add #![feature(ipu_flatten)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/issue-59756.fixed b/src/test/ui/issue-59756.fixed
new file mode 100644
index 00000000000..7b55d0f17e6
--- /dev/null
+++ b/src/test/ui/issue-59756.fixed
@@ -0,0 +1,17 @@
+// run-rustfix
+
+#![allow(warnings)]
+
+struct A;
+struct B;
+
+fn foo() -> Result<A, B> {
+    Ok(A)
+}
+
+fn bar() -> Result<A, B> {
+    foo()
+    //~^ ERROR try expression alternatives have incompatible types [E0308]
+}
+
+fn main() {}
diff --git a/src/test/ui/issue-59756.rs b/src/test/ui/issue-59756.rs
new file mode 100644
index 00000000000..cccae396b72
--- /dev/null
+++ b/src/test/ui/issue-59756.rs
@@ -0,0 +1,17 @@
+// run-rustfix
+
+#![allow(warnings)]
+
+struct A;
+struct B;
+
+fn foo() -> Result<A, B> {
+    Ok(A)
+}
+
+fn bar() -> Result<A, B> {
+    foo()?
+    //~^ ERROR try expression alternatives have incompatible types [E0308]
+}
+
+fn main() {}
diff --git a/src/test/ui/issue-59756.stderr b/src/test/ui/issue-59756.stderr
new file mode 100644
index 00000000000..d46232874fd
--- /dev/null
+++ b/src/test/ui/issue-59756.stderr
@@ -0,0 +1,15 @@
+error[E0308]: try expression alternatives have incompatible types
+  --> $DIR/issue-59756.rs:13:5
+   |
+LL |     foo()?
+   |     ^^^^^-
+   |     |    |
+   |     |    help: try removing this `?`
+   |     expected enum `std::result::Result`, found struct `A`
+   |
+   = note: expected type `std::result::Result<A, B>`
+              found type `A`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/issues/issue-17458.stderr b/src/test/ui/issues/issue-17458.stderr
index a1a8ed9f0cd..69b6ab71e50 100644
--- a/src/test/ui/issues/issue-17458.stderr
+++ b/src/test/ui/issues/issue-17458.stderr
@@ -1,9 +1,10 @@
-error[E0658]: casting pointers to integers in statics is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in statics is unstable
   --> $DIR/issue-17458.rs:1:28
    |
 LL | static X: usize = unsafe { 0 as *const usize as usize };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-18294.stderr b/src/test/ui/issues/issue-18294.stderr
index a7d0392f7f0..d10242434b0 100644
--- a/src/test/ui/issues/issue-18294.stderr
+++ b/src/test/ui/issues/issue-18294.stderr
@@ -1,9 +1,10 @@
-error[E0658]: casting pointers to integers in constants is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in constants is unstable
   --> $DIR/issue-18294.rs:3:31
    |
 LL |     const Y: usize = unsafe { &X as *const u32 as usize };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-20313.stderr b/src/test/ui/issues/issue-20313.stderr
index 87e2e899d3f..405e717c358 100644
--- a/src/test/ui/issues/issue-20313.stderr
+++ b/src/test/ui/issues/issue-20313.stderr
@@ -1,9 +1,10 @@
-error[E0658]: linking to LLVM intrinsics is experimental (see issue #29602)
+error[E0658]: linking to LLVM intrinsics is experimental
   --> $DIR/issue-20313.rs:3:5
    |
 LL |     fn sqrt(x: f32) -> f32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29602
    = help: add #![feature(link_llvm_intrinsics)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-23024.stderr b/src/test/ui/issues/issue-23024.stderr
index a972b36b804..0567dcbec6d 100644
--- a/src/test/ui/issues/issue-23024.stderr
+++ b/src/test/ui/issues/issue-23024.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/issue-23024.rs:9:35
    |
 LL |     println!("{:?}",(vfnfer[0] as Fn)(3));
    |                                   ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error[E0107]: wrong number of type arguments: expected 1, found 0
diff --git a/src/test/ui/issues/issue-23302-1.stderr b/src/test/ui/issues/issue-23302-1.stderr
index 43effc0b3b9..bbdb13a9500 100644
--- a/src/test/ui/issues/issue-23302-1.stderr
+++ b/src/test/ui/issues/issue-23302-1.stderr
@@ -5,7 +5,7 @@ LL |     A = X::A as isize,
    |         ^^^^^^^^^^^^^
    |
    = note: ...which again requires processing `X::A::{{constant}}#0`, completing the cycle
-note: cycle used when const-evaluating `X::A::{{constant}}#0`
+note: cycle used when processing `X::A::{{constant}}#0`
   --> $DIR/issue-23302-1.rs:4:9
    |
 LL |     A = X::A as isize,
diff --git a/src/test/ui/issues/issue-23302-2.stderr b/src/test/ui/issues/issue-23302-2.stderr
index 707d4fa7ed3..03afd82211a 100644
--- a/src/test/ui/issues/issue-23302-2.stderr
+++ b/src/test/ui/issues/issue-23302-2.stderr
@@ -5,7 +5,7 @@ LL |     A = Y::B as isize,
    |         ^^^^^^^^^^^^^
    |
    = note: ...which again requires processing `Y::A::{{constant}}#0`, completing the cycle
-note: cycle used when const-evaluating `Y::A::{{constant}}#0`
+note: cycle used when processing `Y::A::{{constant}}#0`
   --> $DIR/issue-23302-2.rs:4:9
    |
 LL |     A = Y::B as isize,
diff --git a/src/test/ui/issues/issue-25826.stderr b/src/test/ui/issues/issue-25826.stderr
index dc547f7c32c..a800f787e38 100644
--- a/src/test/ui/issues/issue-25826.stderr
+++ b/src/test/ui/issues/issue-25826.stderr
@@ -1,9 +1,10 @@
-error[E0658]: comparing raw pointers inside constant (see issue #53020)
+error[E0658]: comparing raw pointers inside constant
   --> $DIR/issue-25826.rs:3:30
    |
 LL |     const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/53020
    = help: add #![feature(const_compare_raw_pointers)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-30560.rs b/src/test/ui/issues/issue-30560.rs
index c848a1c51ca..d8d4ca608f1 100644
--- a/src/test/ui/issues/issue-30560.rs
+++ b/src/test/ui/issues/issue-30560.rs
@@ -1,10 +1,7 @@
 type Alias = ();
-use Alias::*;
-//~^ ERROR unresolved import `Alias` [E0432]
-//~| not a module `Alias`
-use std::io::Result::*;
-//~^ ERROR unresolved import `std::io::Result` [E0432]
-//~| not a module `Result`
+use Alias::*; //~ ERROR unresolved import `Alias` [E0432]
+
+use std::io::Result::*; //~ ERROR unresolved import `std::io::Result` [E0432]
 
 trait T {}
 use T::*; //~ ERROR items in traits are not importable
diff --git a/src/test/ui/issues/issue-30560.stderr b/src/test/ui/issues/issue-30560.stderr
index 5225f190f9e..b74134aaccc 100644
--- a/src/test/ui/issues/issue-30560.stderr
+++ b/src/test/ui/issues/issue-30560.stderr
@@ -1,5 +1,5 @@
 error: items in traits are not importable.
-  --> $DIR/issue-30560.rs:10:5
+  --> $DIR/issue-30560.rs:7:5
    |
 LL | use T::*;
    |     ^^^^
@@ -8,13 +8,13 @@ error[E0432]: unresolved import `Alias`
   --> $DIR/issue-30560.rs:2:5
    |
 LL | use Alias::*;
-   |     ^^^^^ not a module `Alias`
+   |     ^^^^^ `Alias` is a type alias, not a module
 
 error[E0432]: unresolved import `std::io::Result`
-  --> $DIR/issue-30560.rs:5:14
+  --> $DIR/issue-30560.rs:4:14
    |
 LL | use std::io::Result::*;
-   |              ^^^^^^ not a module `Result`
+   |              ^^^^^^ `Result` is a type alias, not a module
 
 error: aborting due to 3 previous errors
 
diff --git a/src/test/ui/issues/issue-32655.stderr b/src/test/ui/issues/issue-32655.stderr
index 7b3c8e75beb..3ab934f6ca5 100644
--- a/src/test/ui/issues/issue-32655.stderr
+++ b/src/test/ui/issues/issue-32655.stderr
@@ -1,4 +1,4 @@
-error[E0658]: The attribute `derive_Clone` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `derive_Clone` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-32655.rs:6:11
    |
 LL |         #[derive_Clone]
@@ -7,14 +7,16 @@ LL |         #[derive_Clone]
 LL | foo!();
    | ------- in this macro invocation
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `derive_Clone` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `derive_Clone` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-32655.rs:18:7
    |
 LL |     #[derive_Clone]
    |       ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/issues/issue-32829.stderr b/src/test/ui/issues/issue-32829.stderr
index 037f5416fa5..157c8c85af0 100644
--- a/src/test/ui/issues/issue-32829.stderr
+++ b/src/test/ui/issues/issue-32829.stderr
@@ -1,9 +1,10 @@
-error[E0658]: panicking in statics is unstable (see issue #51999)
+error[E0658]: panicking in statics is unstable
   --> $DIR/issue-32829.rs:1:22
    |
 LL | static S : u64 = { { panic!("foo"); 0 } };
    |                      ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51999
    = help: add #![feature(const_panic)] to the crate attributes to enable
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
diff --git a/src/test/ui/issues/issue-36163.stderr b/src/test/ui/issues/issue-36163.stderr
index 4c3f726180d..50e8cf6e88c 100644
--- a/src/test/ui/issues/issue-36163.stderr
+++ b/src/test/ui/issues/issue-36163.stderr
@@ -10,7 +10,7 @@ note: ...which requires processing `A`...
 LL | const A: isize = Foo::B as isize;
    |                  ^^^^^^^^^^^^^^^
    = note: ...which again requires processing `Foo::B::{{constant}}#0`, completing the cycle
-note: cycle used when const-evaluating `Foo::B::{{constant}}#0`
+note: cycle used when processing `Foo::B::{{constant}}#0`
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
diff --git a/src/test/ui/issues/issue-37887.stderr b/src/test/ui/issues/issue-37887.stderr
index 24543a5efaf..9cac105bab5 100644
--- a/src/test/ui/issues/issue-37887.stderr
+++ b/src/test/ui/issues/issue-37887.stderr
@@ -4,12 +4,13 @@ error[E0432]: unresolved import `libc`
 LL |     use libc::*;
    |         ^^^^ maybe a missing `extern crate libc;`?
 
-error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead? (see issue #27812)
+error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
   --> $DIR/issue-37887.rs:2:5
    |
 LL |     extern crate libc;
    |     ^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27812
    = help: add #![feature(rustc_private)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/issues/issue-49074.stderr b/src/test/ui/issues/issue-49074.stderr
index b41d9130f12..29e10f1bf41 100644
--- a/src/test/ui/issues/issue-49074.stderr
+++ b/src/test/ui/issues/issue-49074.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The attribute `marco_use` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `marco_use` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-49074.rs:3:3
    |
 LL | #[marco_use] // typo
    |   ^^^^^^^^^ help: a built-in attribute with a similar name exists: `macro_use`
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: cannot find macro `bar!` in this scope
diff --git a/src/test/ui/issues/issue-51279.stderr b/src/test/ui/issues/issue-51279.stderr
index bc33eacac99..9dd4a9f2381 100644
--- a/src/test/ui/issues/issue-51279.stderr
+++ b/src/test/ui/issues/issue-51279.stderr
@@ -46,12 +46,13 @@ error: #[cfg] cannot be applied on a generic parameter
 LL | type Z<#[ignored] 'a, #[cfg(none)] T> = X<'a, T>;
    |                       ^^^^^^^^^^^^
 
-error[E0658]: The attribute `ignored` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `ignored` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-51279.rs:23:8
    |
 LL | type Z<#[ignored] 'a, #[cfg(none)] T> = X<'a, T>;
    |        ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 9 previous errors
diff --git a/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr b/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
index 8f36a3f9618..bf453571479 100644
--- a/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
+++ b/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
@@ -2,7 +2,10 @@ error[E0308]: try expression alternatives have incompatible types
   --> $DIR/issue-51632-try-desugar-incompatible-types.rs:8:5
    |
 LL |     missing_discourses()?
-   |     ^^^^^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found isize
+   |     ^^^^^^^^^^^^^^^^^^^^-
+   |     |                   |
+   |     |                   help: try removing this `?`
+   |     expected enum `std::result::Result`, found isize
    |
    = note: expected type `std::result::Result<isize, ()>`
               found type `isize`
diff --git a/src/test/ui/issues/issue-51714.rs b/src/test/ui/issues/issue-51714.rs
index 4885e4a2db7..0dc588d75c6 100644
--- a/src/test/ui/issues/issue-51714.rs
+++ b/src/test/ui/issues/issue-51714.rs
@@ -10,5 +10,4 @@ fn main() {
 
     [(); return while let Some(n) = Some(0) {}];
     //~^ ERROR return statement outside of function body
-    //~^^ WARN irrefutable while-let pattern
 }
diff --git a/src/test/ui/issues/issue-51714.stderr b/src/test/ui/issues/issue-51714.stderr
index df11f6b7f5a..023d9013ab4 100644
--- a/src/test/ui/issues/issue-51714.stderr
+++ b/src/test/ui/issues/issue-51714.stderr
@@ -22,14 +22,6 @@ error[E0572]: return statement outside of function body
 LL |     [(); return while let Some(n) = Some(0) {}];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: irrefutable while-let pattern
-  --> $DIR/issue-51714.rs:11:17
-   |
-LL |     [(); return while let Some(n) = Some(0) {}];
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: #[warn(irrefutable_let_patterns)] on by default
-
 error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/src/test/ui/issues/issue-52023-array-size-pointer-cast.stderr b/src/test/ui/issues/issue-52023-array-size-pointer-cast.stderr
index 60e0792954a..f57697e5892 100644
--- a/src/test/ui/issues/issue-52023-array-size-pointer-cast.stderr
+++ b/src/test/ui/issues/issue-52023-array-size-pointer-cast.stderr
@@ -1,9 +1,10 @@
-error[E0658]: casting pointers to integers in constants is unstable (see issue #51910)
+error[E0658]: casting pointers to integers in constants is unstable
   --> $DIR/issue-52023-array-size-pointer-cast.rs:2:17
    |
 LL |     let _ = [0; (&0 as *const i32) as usize];
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/51910
    = help: add #![feature(const_raw_ptr_to_usize_cast)] to the crate attributes to enable
 
 error[E0080]: it is undefined behavior to use this value
diff --git a/src/test/ui/linkage4.stderr b/src/test/ui/linkage4.stderr
index fd86671204e..f2aab164bd7 100644
--- a/src/test/ui/linkage4.stderr
+++ b/src/test/ui/linkage4.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the `linkage` attribute is experimental and not portable across platforms (see issue #29603)
+error[E0658]: the `linkage` attribute is experimental and not portable across platforms
   --> $DIR/linkage4.rs:1:1
    |
 LL | #[linkage = "external"]
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29603
    = help: add #![feature(linkage)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/macros/macro-path-prelude-fail-1.rs b/src/test/ui/macros/macro-path-prelude-fail-1.rs
index 354c2bf8571..cd695ca916e 100644
--- a/src/test/ui/macros/macro-path-prelude-fail-1.rs
+++ b/src/test/ui/macros/macro-path-prelude-fail-1.rs
@@ -2,8 +2,8 @@
 
 mod m {
     fn check() {
-        Vec::clone!(); //~ ERROR failed to resolve: not a module `Vec`
-        u8::clone!(); //~ ERROR failed to resolve: not a module `u8`
+        Vec::clone!(); //~ ERROR failed to resolve: `Vec` is a struct, not a module
+        u8::clone!(); //~ ERROR failed to resolve: `u8` is a builtin type, not a module
     }
 }
 
diff --git a/src/test/ui/macros/macro-path-prelude-fail-1.stderr b/src/test/ui/macros/macro-path-prelude-fail-1.stderr
index 551d2fe8ce0..b68e89f07f6 100644
--- a/src/test/ui/macros/macro-path-prelude-fail-1.stderr
+++ b/src/test/ui/macros/macro-path-prelude-fail-1.stderr
@@ -1,14 +1,14 @@
-error[E0433]: failed to resolve: not a module `Vec`
+error[E0433]: failed to resolve: `Vec` is a struct, not a module
   --> $DIR/macro-path-prelude-fail-1.rs:5:9
    |
 LL |         Vec::clone!();
-   |         ^^^ not a module `Vec`
+   |         ^^^ `Vec` is a struct, not a module
 
-error[E0433]: failed to resolve: not a module `u8`
+error[E0433]: failed to resolve: `u8` is a builtin type, not a module
   --> $DIR/macro-path-prelude-fail-1.rs:6:9
    |
 LL |         u8::clone!();
-   |         ^^ not a module `u8`
+   |         ^^ `u8` is a builtin type, not a module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/macros/macro-reexport-removed.stderr b/src/test/ui/macros/macro-reexport-removed.stderr
index 302952909be..600d5d4cc9a 100644
--- a/src/test/ui/macros/macro-reexport-removed.stderr
+++ b/src/test/ui/macros/macro-reexport-removed.stderr
@@ -10,12 +10,13 @@ note: subsumed by `pub use`
 LL | #![feature(macro_reexport)]
    |            ^^^^^^^^^^^^^^
 
-error[E0658]: The attribute `macro_reexport` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `macro_reexport` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/macro-reexport-removed.rs:5:3
    |
 LL | #[macro_reexport(macro_one)]
    |   ^^^^^^^^^^^^^^ help: a built-in attribute with a similar name exists: `macro_export`
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/macros/macros-in-extern.stderr b/src/test/ui/macros/macros-in-extern.stderr
index 1d0c28752bc..ec7c37402d4 100644
--- a/src/test/ui/macros/macros-in-extern.stderr
+++ b/src/test/ui/macros/macros-in-extern.stderr
@@ -1,25 +1,28 @@
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:26:5
    |
 LL |     returns_isize!(rust_get_test_int);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:28:5
    |
 LL |     takes_u32_returns_u32!(rust_dbg_extern_identity_u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:30:5
    |
 LL |     emits_nothing!();
    |     ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/panic-runtime/needs-gate.stderr b/src/test/ui/panic-runtime/needs-gate.stderr
index 5b8ff82d1fd..72999a0de89 100644
--- a/src/test/ui/panic-runtime/needs-gate.stderr
+++ b/src/test/ui/panic-runtime/needs-gate.stderr
@@ -1,17 +1,19 @@
-error[E0658]: the `#[panic_runtime]` attribute is an experimental feature (see issue #32837)
+error[E0658]: the `#[panic_runtime]` attribute is an experimental feature
   --> $DIR/needs-gate.rs:4:1
    |
 LL | #![panic_runtime]
    | ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32837
    = help: add #![feature(panic_runtime)] to the crate attributes to enable
 
-error[E0658]: the `#[needs_panic_runtime]` attribute is an experimental feature (see issue #32837)
+error[E0658]: the `#[needs_panic_runtime]` attribute is an experimental feature
   --> $DIR/needs-gate.rs:5:1
    |
 LL | #![needs_panic_runtime]
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/32837
    = help: add #![feature(needs_panic_runtime)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/parser/recover-missing-semi.rs b/src/test/ui/parser/recover-missing-semi.rs
new file mode 100644
index 00000000000..1893dc716be
--- /dev/null
+++ b/src/test/ui/parser/recover-missing-semi.rs
@@ -0,0 +1,13 @@
+fn main() {
+    let _: usize = ()
+    //~^ ERROR mismatched types
+    let _ = 3;
+    //~^ ERROR expected one of
+}
+
+fn foo() -> usize {
+    let _: usize = ()
+    //~^ ERROR mismatched types
+    return 3;
+    //~^ ERROR expected one of
+}
diff --git a/src/test/ui/parser/recover-missing-semi.stderr b/src/test/ui/parser/recover-missing-semi.stderr
new file mode 100644
index 00000000000..99339e4dd50
--- /dev/null
+++ b/src/test/ui/parser/recover-missing-semi.stderr
@@ -0,0 +1,39 @@
+error: expected one of `.`, `;`, `?`, or an operator, found `let`
+  --> $DIR/recover-missing-semi.rs:4:5
+   |
+LL |     let _: usize = ()
+   |                      - help: a semicolon may be missing here
+LL |
+LL |     let _ = 3;
+   |     ^^^
+
+error: expected one of `.`, `;`, `?`, or an operator, found `return`
+  --> $DIR/recover-missing-semi.rs:11:5
+   |
+LL |     let _: usize = ()
+   |                      - help: a semicolon may be missing here
+LL |
+LL |     return 3;
+   |     ^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/recover-missing-semi.rs:2:20
+   |
+LL |     let _: usize = ()
+   |                    ^^ expected usize, found ()
+   |
+   = note: expected type `usize`
+              found type `()`
+
+error[E0308]: mismatched types
+  --> $DIR/recover-missing-semi.rs:9:20
+   |
+LL |     let _: usize = ()
+   |                    ^^ expected usize, found ()
+   |
+   = note: expected type `usize`
+              found type `()`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/proc-macro/attr-stmt-expr.stderr b/src/test/ui/proc-macro/attr-stmt-expr.stderr
index 34ee012ab31..3928a973eab 100644
--- a/src/test/ui/proc-macro/attr-stmt-expr.stderr
+++ b/src/test/ui/proc-macro/attr-stmt-expr.stderr
@@ -1,17 +1,19 @@
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/attr-stmt-expr.rs:10:5
    |
 LL |     #[expect_print_expr]
    |     ^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/attr-stmt-expr.rs:23:5
    |
 LL |     #[expect_expr]
    |     ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/proc-macro/derive-helper-shadowing.stderr b/src/test/ui/proc-macro/derive-helper-shadowing.stderr
index 5f2009b384b..58139353492 100644
--- a/src/test/ui/proc-macro/derive-helper-shadowing.stderr
+++ b/src/test/ui/proc-macro/derive-helper-shadowing.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The attribute `my_attr` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `my_attr` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/derive-helper-shadowing.rs:20:15
    |
 LL |             #[my_attr]
    |               ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error[E0659]: `my_attr` is ambiguous (derive helper attribute vs any other name)
diff --git a/src/test/ui/proc-macro/derive-still-gated.stderr b/src/test/ui/proc-macro/derive-still-gated.stderr
index f7c8960372e..d235343ff16 100644
--- a/src/test/ui/proc-macro/derive-still-gated.stderr
+++ b/src/test/ui/proc-macro/derive-still-gated.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The attribute `derive_A` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `derive_A` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/derive-still-gated.rs:8:3
    |
 LL | #[derive_A]
    |   ^^^^^^^^ help: a built-in attribute with a similar name exists: `derive`
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/proc-macro/expand-to-unstable-2.stderr b/src/test/ui/proc-macro/expand-to-unstable-2.stderr
index b322f8e9d56..e2f51dd3d5d 100644
--- a/src/test/ui/proc-macro/expand-to-unstable-2.stderr
+++ b/src/test/ui/proc-macro/expand-to-unstable-2.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics (see issue #29642)
+error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics
   --> $DIR/expand-to-unstable-2.rs:8:10
    |
 LL | #[derive(Unstable)]
    |          ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/proc-macro/issue-41211.stderr b/src/test/ui/proc-macro/issue-41211.stderr
index f75481e4829..dfb2f6f63d8 100644
--- a/src/test/ui/proc-macro/issue-41211.stderr
+++ b/src/test/ui/proc-macro/issue-41211.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The attribute `emit_unchanged` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `emit_unchanged` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-41211.rs:8:4
    |
 LL | #![emit_unchanged]
    |    ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: inconsistent resolution for a macro: first custom attribute, then attribute macro
diff --git a/src/test/ui/proc-macro/macros-in-extern.stderr b/src/test/ui/proc-macro/macros-in-extern.stderr
index 8a48656d087..61571650f2f 100644
--- a/src/test/ui/proc-macro/macros-in-extern.stderr
+++ b/src/test/ui/proc-macro/macros-in-extern.stderr
@@ -1,25 +1,28 @@
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:15:5
    |
 LL |     #[no_output]
    |     ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:19:5
    |
 LL |     #[nop_attr]
    |     ^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
-error[E0658]: macro invocations in `extern {}` blocks are experimental (see issue #49476)
+error[E0658]: macro invocations in `extern {}` blocks are experimental
   --> $DIR/macros-in-extern.rs:23:5
    |
 LL |     emit_input!(fn rust_dbg_extern_identity_u32(arg: u32) -> u32;);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/49476
    = help: add #![feature(macros_in_extern)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/proc-macro/more-gates.stderr b/src/test/ui/proc-macro/more-gates.stderr
index c6c2954f939..80985ce7523 100644
--- a/src/test/ui/proc-macro/more-gates.stderr
+++ b/src/test/ui/proc-macro/more-gates.stderr
@@ -1,41 +1,46 @@
-error[E0658]: procedural macros cannot expand to macro definitions (see issue #54727)
+error[E0658]: procedural macros cannot expand to macro definitions
   --> $DIR/more-gates.rs:9:1
    |
 LL | #[attr2mac1]
    | ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot expand to macro definitions (see issue #54727)
+error[E0658]: procedural macros cannot expand to macro definitions
   --> $DIR/more-gates.rs:12:1
    |
 LL | #[attr2mac2]
    | ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot expand to macro definitions (see issue #54727)
+error[E0658]: procedural macros cannot expand to macro definitions
   --> $DIR/more-gates.rs:16:1
    |
 LL | mac2mac1!();
    | ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot expand to macro definitions (see issue #54727)
+error[E0658]: procedural macros cannot expand to macro definitions
   --> $DIR/more-gates.rs:17:1
    |
 LL | mac2mac2!();
    | ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot expand to macro definitions (see issue #54727)
+error[E0658]: procedural macros cannot expand to macro definitions
   --> $DIR/more-gates.rs:19:1
    |
 LL | tricky!();
    | ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
 error: aborting due to 5 previous errors
diff --git a/src/test/ui/proc-macro/proc-macro-attributes.stderr b/src/test/ui/proc-macro/proc-macro-attributes.stderr
index f8f1e7cd988..084c7289d04 100644
--- a/src/test/ui/proc-macro/proc-macro-attributes.stderr
+++ b/src/test/ui/proc-macro/proc-macro-attributes.stderr
@@ -1,9 +1,10 @@
-error[E0658]: The attribute `C` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `C` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/proc-macro-attributes.rs:7:3
    |
 LL | #[C]
    |   ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error[E0659]: `B` is ambiguous (derive helper attribute vs any other name)
diff --git a/src/test/ui/proc-macro/proc-macro-gates.stderr b/src/test/ui/proc-macro/proc-macro-gates.stderr
index 4ae8e63df72..1bb864b52ea 100644
--- a/src/test/ui/proc-macro/proc-macro-gates.stderr
+++ b/src/test/ui/proc-macro/proc-macro-gates.stderr
@@ -1,33 +1,37 @@
-error[E0658]: non-builtin inner attributes are unstable (see issue #54726)
+error[E0658]: non-builtin inner attributes are unstable
   --> $DIR/proc-macro-gates.rs:11:5
    |
 LL |     #![a]
    |     ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54726
    = help: add #![feature(custom_inner_attributes)] to the crate attributes to enable
 
-error[E0658]: non-builtin inner attributes are unstable (see issue #54726)
+error[E0658]: non-builtin inner attributes are unstable
   --> $DIR/proc-macro-gates.rs:18:5
    |
 LL |     #![a]
    |     ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54726
    = help: add #![feature(custom_inner_attributes)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to modules (see issue #54727)
+error[E0658]: custom attributes cannot be applied to modules
   --> $DIR/proc-macro-gates.rs:14:1
    |
 LL | #[a]
    | ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to modules (see issue #54727)
+error[E0658]: custom attributes cannot be applied to modules
   --> $DIR/proc-macro-gates.rs:18:5
    |
 LL |     #![a]
    |     ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
 error: custom attribute invocations must be of the form #[foo] or #[foo(..)], the macro name must only be followed by a delimiter token
@@ -36,100 +40,112 @@ error: custom attribute invocations must be of the form #[foo] or #[foo(..)], th
 LL | #[a = "y"]
    | ^^^^^^^^^^
 
-error[E0658]: custom attributes cannot be applied to statements (see issue #54727)
+error[E0658]: custom attributes cannot be applied to statements
   --> $DIR/proc-macro-gates.rs:31:5
    |
 LL |     #[a]
    |     ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to statements (see issue #54727)
+error[E0658]: custom attributes cannot be applied to statements
   --> $DIR/proc-macro-gates.rs:35:5
    |
 LL |     #[a]
    |     ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to statements (see issue #54727)
+error[E0658]: custom attributes cannot be applied to statements
   --> $DIR/proc-macro-gates.rs:39:5
    |
 LL |     #[a]
    |     ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to expressions (see issue #54727)
+error[E0658]: custom attributes cannot be applied to expressions
   --> $DIR/proc-macro-gates.rs:43:14
    |
 LL |     let _x = #[a] 2;
    |              ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to expressions (see issue #54727)
+error[E0658]: custom attributes cannot be applied to expressions
   --> $DIR/proc-macro-gates.rs:46:15
    |
 LL |     let _x = [#[a] 2];
    |               ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: custom attributes cannot be applied to expressions (see issue #54727)
+error[E0658]: custom attributes cannot be applied to expressions
   --> $DIR/proc-macro-gates.rs:49:14
    |
 LL |     let _x = #[a] println!();
    |              ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to types (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to types
   --> $DIR/proc-macro-gates.rs:53:13
    |
 LL |     let _x: m!(u32) = 3;
    |             ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to patterns (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to patterns
   --> $DIR/proc-macro-gates.rs:54:12
    |
 LL |     if let m!(Some(_x)) = Some(3) {}
    |            ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to statements (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to statements
   --> $DIR/proc-macro-gates.rs:56:5
    |
 LL |     m!(struct S;);
    |     ^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to statements (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to statements
   --> $DIR/proc-macro-gates.rs:57:5
    |
 LL |     m!(let _x = 3;);
    |     ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to expressions (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to expressions
   --> $DIR/proc-macro-gates.rs:59:14
    |
 LL |     let _x = m!(3);
    |              ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
-error[E0658]: procedural macros cannot be expanded to expressions (see issue #54727)
+error[E0658]: procedural macros cannot be expanded to expressions
   --> $DIR/proc-macro-gates.rs:60:15
    |
 LL |     let _x = [m!(3)];
    |               ^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54727
    = help: add #![feature(proc_macro_hygiene)] to the crate attributes to enable
 
 error: aborting due to 17 previous errors
diff --git a/src/test/ui/proc-macro/proc-macro-gates2.stderr b/src/test/ui/proc-macro/proc-macro-gates2.stderr
index 89ad527a43c..0e8236f460f 100644
--- a/src/test/ui/proc-macro/proc-macro-gates2.stderr
+++ b/src/test/ui/proc-macro/proc-macro-gates2.stderr
@@ -1,17 +1,19 @@
-error[E0658]: The attribute `a` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `a` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/proc-macro-gates2.rs:13:11
    |
 LL | fn _test6<#[a] T>() {}
    |           ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `a` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `a` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/proc-macro-gates2.rs:18:9
    |
 LL |         #[a]
    |         ^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/reserved/reserved-attr-on-macro.stderr b/src/test/ui/reserved/reserved-attr-on-macro.stderr
index 3e082e53ca8..c8738d1ed34 100644
--- a/src/test/ui/reserved/reserved-attr-on-macro.stderr
+++ b/src/test/ui/reserved/reserved-attr-on-macro.stderr
@@ -1,9 +1,10 @@
-error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics (see issue #29642)
+error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics
   --> $DIR/reserved-attr-on-macro.rs:1:3
    |
 LL | #[rustc_attribute_should_be_reserved]
    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
 error: cannot determine resolution for the macro `foo`
diff --git a/src/test/ui/resolve/resolve-variant-assoc-item.rs b/src/test/ui/resolve/resolve-variant-assoc-item.rs
index f0f55c0c667..db4fedfb0bd 100644
--- a/src/test/ui/resolve/resolve-variant-assoc-item.rs
+++ b/src/test/ui/resolve/resolve-variant-assoc-item.rs
@@ -2,6 +2,6 @@ enum E { V }
 use E::V;
 
 fn main() {
-    E::V::associated_item; //~ ERROR failed to resolve: not a module `V`
-    V::associated_item; //~ ERROR failed to resolve: not a module `V`
+    E::V::associated_item; //~ ERROR failed to resolve: `V` is a variant, not a module
+    V::associated_item; //~ ERROR failed to resolve: `V` is a variant, not a module
 }
diff --git a/src/test/ui/resolve/resolve-variant-assoc-item.stderr b/src/test/ui/resolve/resolve-variant-assoc-item.stderr
index 173976d707c..4be1019968b 100644
--- a/src/test/ui/resolve/resolve-variant-assoc-item.stderr
+++ b/src/test/ui/resolve/resolve-variant-assoc-item.stderr
@@ -1,14 +1,14 @@
-error[E0433]: failed to resolve: not a module `V`
+error[E0433]: failed to resolve: `V` is a variant, not a module
   --> $DIR/resolve-variant-assoc-item.rs:5:8
    |
 LL |     E::V::associated_item;
-   |        ^ not a module `V`
+   |        ^ `V` is a variant, not a module
 
-error[E0433]: failed to resolve: not a module `V`
+error[E0433]: failed to resolve: `V` is a variant, not a module
   --> $DIR/resolve-variant-assoc-item.rs:6:5
    |
 LL |     V::associated_item;
-   |     ^ not a module `V`
+   |     ^ `V` is a variant, not a module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/rfc1445/feature-gate.no_gate.stderr b/src/test/ui/rfc1445/feature-gate.no_gate.stderr
index 370b74b8779..3a2014fab09 100644
--- a/src/test/ui/rfc1445/feature-gate.no_gate.stderr
+++ b/src/test/ui/rfc1445/feature-gate.no_gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the semantics of constant patterns is not yet settled (see issue #31434)
+error[E0658]: the semantics of constant patterns is not yet settled
   --> $DIR/feature-gate.rs:13:1
    |
 LL | #[structural_match]
    | ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/31434
    = help: add #![feature(structural_match)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/rust-2018/uniform-paths/prelude-fail.stderr b/src/test/ui/rust-2018/uniform-paths/prelude-fail.stderr
index a61af699cdc..42daf7c6fb1 100644
--- a/src/test/ui/rust-2018/uniform-paths/prelude-fail.stderr
+++ b/src/test/ui/rust-2018/uniform-paths/prelude-fail.stderr
@@ -8,7 +8,7 @@ error[E0432]: unresolved import `rustfmt`
   --> $DIR/prelude-fail.rs:7:5
    |
 LL | use rustfmt::skip as imported_rustfmt_skip;
-   |     ^^^^^^^ not a module `rustfmt`
+   |     ^^^^^^^ `rustfmt` is a tool module, not a module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/span/gated-features-attr-spans.stderr b/src/test/ui/span/gated-features-attr-spans.stderr
index 45d14f32f96..938edbe463f 100644
--- a/src/test/ui/span/gated-features-attr-spans.stderr
+++ b/src/test/ui/span/gated-features-attr-spans.stderr
@@ -1,9 +1,10 @@
-error[E0658]: SIMD types are experimental and possibly buggy (see issue #27731)
+error[E0658]: SIMD types are experimental and possibly buggy
   --> $DIR/gated-features-attr-spans.rs:1:1
    |
 LL | #[repr(simd)]
    | ^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/27731
    = help: add #![feature(repr_simd)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/span/issue-36530.stderr b/src/test/ui/span/issue-36530.stderr
index 05b2ca90570..ee479d6c791 100644
--- a/src/test/ui/span/issue-36530.stderr
+++ b/src/test/ui/span/issue-36530.stderr
@@ -1,25 +1,28 @@
-error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-36530.rs:3:3
    |
 LL | #[foo]
    |   ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: non-builtin inner attributes are unstable (see issue #54726)
+error[E0658]: non-builtin inner attributes are unstable
   --> $DIR/issue-36530.rs:5:5
    |
 LL |     #![foo]
    |     ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/54726
    = help: add #![feature(custom_inner_attributes)] to the crate attributes to enable
 
-error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `foo` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/issue-36530.rs:5:8
    |
 LL |     #![foo]
    |        ^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr b/src/test/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
index 0b20a19d2e1..b95e62edaaa 100644
--- a/src/test/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
+++ b/src/test/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
@@ -1,4 +1,4 @@
-error[E0658]: specialization is unstable (see issue #31844)
+error[E0658]: specialization is unstable
   --> $DIR/specialization-feature-gate-default.rs:7:1
    |
 LL | / default impl<T> Foo for T {
@@ -6,6 +6,7 @@ LL | |     fn foo(&self) {}
 LL | | }
    | |_^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/31844
    = help: add #![feature(specialization)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/specialization/specialization-feature-gate-default.stderr b/src/test/ui/specialization/specialization-feature-gate-default.stderr
index ad33908eff6..e649f2aa47a 100644
--- a/src/test/ui/specialization/specialization-feature-gate-default.stderr
+++ b/src/test/ui/specialization/specialization-feature-gate-default.stderr
@@ -1,9 +1,10 @@
-error[E0658]: specialization is unstable (see issue #31844)
+error[E0658]: specialization is unstable
   --> $DIR/specialization-feature-gate-default.rs:10:5
    |
 LL |     default fn foo(&self) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/31844
    = help: add #![feature(specialization)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/stability-attribute/stability-attribute-issue.rs b/src/test/ui/stability-attribute/stability-attribute-issue.rs
index fc4a7dab1af..ca4d7cc6a6c 100644
--- a/src/test/ui/stability-attribute/stability-attribute-issue.rs
+++ b/src/test/ui/stability-attribute/stability-attribute-issue.rs
@@ -8,7 +8,7 @@ use stability_attribute_issue::*;
 
 fn main() {
     unstable();
-    //~^ ERROR use of unstable library feature 'unstable_test_feature' (see issue #1)
+    //~^ ERROR use of unstable library feature 'unstable_test_feature'
     unstable_msg();
-    //~^ ERROR use of unstable library feature 'unstable_test_feature': message (see issue #2)
+    //~^ ERROR use of unstable library feature 'unstable_test_feature': message
 }
diff --git a/src/test/ui/stability-attribute/stability-attribute-issue.stderr b/src/test/ui/stability-attribute/stability-attribute-issue.stderr
index 94fdc0db3d9..36e192e583e 100644
--- a/src/test/ui/stability-attribute/stability-attribute-issue.stderr
+++ b/src/test/ui/stability-attribute/stability-attribute-issue.stderr
@@ -1,17 +1,19 @@
-error[E0658]: use of unstable library feature 'unstable_test_feature' (see issue #1)
+error[E0658]: use of unstable library feature 'unstable_test_feature'
   --> $DIR/stability-attribute-issue.rs:10:5
    |
 LL |     unstable();
    |     ^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/1
    = help: add #![feature(unstable_test_feature)] to the crate attributes to enable
 
-error[E0658]: use of unstable library feature 'unstable_test_feature': message (see issue #2)
+error[E0658]: use of unstable library feature 'unstable_test_feature': message
   --> $DIR/stability-attribute-issue.rs:12:5
    |
 LL |     unstable_msg();
    |     ^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/2
    = help: add #![feature(unstable_test_feature)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/stmt_expr_attrs_no_feature.rs b/src/test/ui/stmt_expr_attrs_no_feature.rs
index 0a71d8d1333..8952175e425 100644
--- a/src/test/ui/stmt_expr_attrs_no_feature.rs
+++ b/src/test/ui/stmt_expr_attrs_no_feature.rs
@@ -91,42 +91,42 @@ item_mac!(e);
 extern {
     #[cfg(unset)]
     fn x(a: [u8; #[attr] 5]);
-    fn y(a: [u8; #[attr] 5]); //~ ERROR 15701
+    fn y(a: [u8; #[attr] 5]); //~ ERROR attributes on expressions are experimental
 }
 
 struct Foo;
 impl Foo {
     #[cfg(unset)]
     const X: u8 = #[attr] 5;
-    const Y: u8 = #[attr] 5; //~ ERROR 15701
+    const Y: u8 = #[attr] 5; //~ ERROR attributes on expressions are experimental
 }
 
 trait Bar {
     #[cfg(unset)]
     const X: [u8; #[attr] 5];
-    const Y: [u8; #[attr] 5]; //~ ERROR 15701
+    const Y: [u8; #[attr] 5]; //~ ERROR attributes on expressions are experimental
 }
 
 struct Joyce {
     #[cfg(unset)]
     field: [u8; #[attr] 5],
-    field2: [u8; #[attr] 5] //~ ERROR 15701
+    field2: [u8; #[attr] 5] //~ ERROR attributes on expressions are experimental
 }
 
 struct Walky(
     #[cfg(unset)] [u8; #[attr] 5],
-    [u8; #[attr] 5] //~ ERROR 15701
+    [u8; #[attr] 5] //~ ERROR attributes on expressions are experimental
 );
 
 enum Mike {
     Happy(
         #[cfg(unset)] [u8; #[attr] 5],
-        [u8; #[attr] 5] //~ ERROR 15701
+        [u8; #[attr] 5] //~ ERROR attributes on expressions are experimental
     ),
     Angry {
         #[cfg(unset)]
         field: [u8; #[attr] 5],
-        field2: [u8; #[attr] 5] //~ ERROR 15701
+        field2: [u8; #[attr] 5] //~ ERROR attributes on expressions are experimental
     }
 }
 
@@ -134,7 +134,7 @@ fn pat() {
     match 5 {
         #[cfg(unset)]
         5 => #[attr] (),
-        6 => #[attr] (), //~ ERROR 15701
+        6 => #[attr] (), //~ ERROR attributes on expressions are experimental
         _ => (),
     }
 }
diff --git a/src/test/ui/stmt_expr_attrs_no_feature.stderr b/src/test/ui/stmt_expr_attrs_no_feature.stderr
index c644126535d..1b5e989af7b 100644
--- a/src/test/ui/stmt_expr_attrs_no_feature.stderr
+++ b/src/test/ui/stmt_expr_attrs_no_feature.stderr
@@ -1,73 +1,82 @@
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:13:5
    |
 LL |     #[attr]
    |     ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:94:18
    |
 LL |     fn y(a: [u8; #[attr] 5]);
    |                  ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:101:19
    |
 LL |     const Y: u8 = #[attr] 5;
    |                   ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:107:19
    |
 LL |     const Y: [u8; #[attr] 5];
    |                   ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:113:18
    |
 LL |     field2: [u8; #[attr] 5]
    |                  ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:118:10
    |
 LL |     [u8; #[attr] 5]
    |          ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:124:14
    |
 LL |         [u8; #[attr] 5]
    |              ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:129:22
    |
 LL |         field2: [u8; #[attr] 5]
    |                      ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
-error[E0658]: attributes on expressions are experimental. (see issue #15701)
+error[E0658]: attributes on expressions are experimental
   --> $DIR/stmt_expr_attrs_no_feature.rs:137:14
    |
 LL |         6 => #[attr] (),
    |              ^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/15701
    = help: add #![feature(stmt_expr_attributes)] to the crate attributes to enable
 
 error: aborting due to 9 previous errors
diff --git a/src/test/ui/suggestions/attribute-typos.stderr b/src/test/ui/suggestions/attribute-typos.stderr
index 077c955431a..8367ff20aa4 100644
--- a/src/test/ui/suggestions/attribute-typos.stderr
+++ b/src/test/ui/suggestions/attribute-typos.stderr
@@ -1,25 +1,28 @@
-error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics (see issue #29642)
+error[E0658]: unless otherwise specified, attributes with the prefix `rustc_` are reserved for internal compiler diagnostics
   --> $DIR/attribute-typos.rs:11:3
    |
 LL | #[rustc_err]
    |   ^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(rustc_attrs)] to the crate attributes to enable
 
-error[E0658]: The attribute `tests` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `tests` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/attribute-typos.rs:6:3
    |
 LL | #[tests]
    |   ^^^^^ help: a built-in attribute with a similar name exists: `test`
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
-error[E0658]: The attribute `deprcated` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
+error[E0658]: The attribute `deprcated` is currently unknown to the compiler and may have meaning added to it in the future
   --> $DIR/attribute-typos.rs:1:3
    |
 LL | #[deprcated]
    |   ^^^^^^^^^ help: a built-in attribute with a similar name exists: `deprecated`
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29642
    = help: add #![feature(custom_attribute)] to the crate attributes to enable
 
 error: aborting due to 3 previous errors
diff --git a/src/test/ui/syntax-trait-polarity-feature-gate.stderr b/src/test/ui/syntax-trait-polarity-feature-gate.stderr
index 7b9c3da3712..86b4bc1157b 100644
--- a/src/test/ui/syntax-trait-polarity-feature-gate.stderr
+++ b/src/test/ui/syntax-trait-polarity-feature-gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now (see issue #13231)
+error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now
   --> $DIR/syntax-trait-polarity-feature-gate.rs:7:1
    |
 LL | impl !Send for TestType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/13231
    = help: add #![feature(optin_builtin_traits)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/target-feature-gate.stderr b/src/test/ui/target-feature-gate.stderr
index 24141d0064f..155298e5062 100644
--- a/src/test/ui/target-feature-gate.stderr
+++ b/src/test/ui/target-feature-gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: the target feature `avx512bw` is currently unstable (see issue #44839)
+error[E0658]: the target feature `avx512bw` is currently unstable
   --> $DIR/target-feature-gate.rs:28:18
    |
 LL | #[target_feature(enable = "avx512bw")]
    |                  ^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44839
    = help: add #![feature(avx512_target_feature)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/trace_macros-gate.stderr b/src/test/ui/trace_macros-gate.stderr
index 4d2fd554a06..e0ffcfe295f 100644
--- a/src/test/ui/trace_macros-gate.stderr
+++ b/src/test/ui/trace_macros-gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: `trace_macros` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `trace_macros` is not stable enough for use and is subject to change
   --> $DIR/trace_macros-gate.rs:4:5
    |
 LL |     trace_macros!();
    |     ^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(trace_macros)] to the crate attributes to enable
 
 error: trace_macros! accepts only `true` or `false`
@@ -12,23 +13,25 @@ error: trace_macros! accepts only `true` or `false`
 LL |     trace_macros!();
    |     ^^^^^^^^^^^^^^^^
 
-error[E0658]: `trace_macros` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `trace_macros` is not stable enough for use and is subject to change
   --> $DIR/trace_macros-gate.rs:6:5
    |
 LL |     trace_macros!(true);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(trace_macros)] to the crate attributes to enable
 
-error[E0658]: `trace_macros` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `trace_macros` is not stable enough for use and is subject to change
   --> $DIR/trace_macros-gate.rs:7:5
    |
 LL |     trace_macros!(false);
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(trace_macros)] to the crate attributes to enable
 
-error[E0658]: `trace_macros` is not stable enough for use and is subject to change (see issue #29598)
+error[E0658]: `trace_macros` is not stable enough for use and is subject to change
   --> $DIR/trace_macros-gate.rs:10:26
    |
 LL |         ($x: ident) => { trace_macros!($x) }
@@ -37,6 +40,7 @@ LL |         ($x: ident) => { trace_macros!($x) }
 LL |     expando!(true);
    |     --------------- in this macro invocation
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29598
    = help: add #![feature(trace_macros)] to the crate attributes to enable
 
 error: aborting due to 5 previous errors
diff --git a/src/test/ui/try-block/try-block-catch.rs b/src/test/ui/try-block/try-block-catch.rs
new file mode 100644
index 00000000000..d165015611d
--- /dev/null
+++ b/src/test/ui/try-block/try-block-catch.rs
@@ -0,0 +1,10 @@
+// compile-flags: --edition 2018
+
+#![feature(try_blocks)]
+
+fn main() {
+    let res: Option<bool> = try {
+        true
+    } catch { };
+    //~^ ERROR keyword `catch` cannot follow a `try` block
+}
diff --git a/src/test/ui/try-block/try-block-catch.stderr b/src/test/ui/try-block/try-block-catch.stderr
new file mode 100644
index 00000000000..39cf943f4d8
--- /dev/null
+++ b/src/test/ui/try-block/try-block-catch.stderr
@@ -0,0 +1,10 @@
+error: keyword `catch` cannot follow a `try` block
+  --> $DIR/try-block-catch.rs:8:7
+   |
+LL |     } catch { };
+   |       ^^^^^
+   |
+   = help: try using `match` on the result of the `try` block instead
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/ufcs/ufcs-partially-resolved.rs b/src/test/ui/ufcs/ufcs-partially-resolved.rs
index 4efded8b376..82a593ff16c 100644
--- a/src/test/ui/ufcs/ufcs-partially-resolved.rs
+++ b/src/test/ui/ufcs/ufcs-partially-resolved.rs
@@ -45,9 +45,9 @@ fn main() {
     <u8 as E::N>::NN; //~ ERROR cannot find method or associated constant `NN` in `E::N`
     <u8 as A::N>::NN; //~ ERROR cannot find method or associated constant `NN` in `A::N`
     let _: <u8 as Tr::Y>::NN; //~ ERROR cannot find associated type `NN` in `Tr::Y`
-    let _: <u8 as E::Y>::NN; //~ ERROR failed to resolve: not a module `Y`
+    let _: <u8 as E::Y>::NN; //~ ERROR failed to resolve: `Y` is a variant, not a module
     <u8 as Tr::Y>::NN; //~ ERROR cannot find method or associated constant `NN` in `Tr::Y`
-    <u8 as E::Y>::NN; //~ ERROR failed to resolve: not a module `Y`
+    <u8 as E::Y>::NN; //~ ERROR failed to resolve: `Y` is a variant, not a module
 
     let _: <u8 as Dr>::Z; //~ ERROR expected associated type, found method `Dr::Z`
     <u8 as Dr>::X; //~ ERROR expected method or associated constant, found associated type `Dr::X`
diff --git a/src/test/ui/ufcs/ufcs-partially-resolved.stderr b/src/test/ui/ufcs/ufcs-partially-resolved.stderr
index 900c7297211..c399a32bc56 100644
--- a/src/test/ui/ufcs/ufcs-partially-resolved.stderr
+++ b/src/test/ui/ufcs/ufcs-partially-resolved.stderr
@@ -1,14 +1,14 @@
-error[E0433]: failed to resolve: not a module `Y`
+error[E0433]: failed to resolve: `Y` is a variant, not a module
   --> $DIR/ufcs-partially-resolved.rs:48:22
    |
 LL |     let _: <u8 as E::Y>::NN;
-   |                      ^ not a module `Y`
+   |                      ^ `Y` is a variant, not a module
 
-error[E0433]: failed to resolve: not a module `Y`
+error[E0433]: failed to resolve: `Y` is a variant, not a module
   --> $DIR/ufcs-partially-resolved.rs:50:15
    |
 LL |     <u8 as E::Y>::NN;
-   |               ^ not a module `Y`
+   |               ^ `Y` is a variant, not a module
 
 error[E0576]: cannot find associated type `N` in trait `Tr`
   --> $DIR/ufcs-partially-resolved.rs:19:24
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-feature-gate.stderr b/src/test/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
index 038167ae9d7..1604aa4a0f7 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
@@ -1,9 +1,10 @@
-error[E0658]: parenthetical notation is only stable when used with `Fn`-family traits (see issue #29625)
+error[E0658]: parenthetical notation is only stable when used with `Fn`-family traits
   --> $DIR/unboxed-closure-feature-gate.rs:13:16
    |
 LL |     let x: Box<Foo(isize)>;
    |                ^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error: aborting due to previous error
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-not-used-on-fn.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-not-used-on-fn.stderr
index 90f04a52d37..0901126a3fe 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-not-used-on-fn.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-not-used-on-fn.stderr
@@ -1,17 +1,19 @@
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/unboxed-closure-sugar-not-used-on-fn.rs:3:13
    |
 LL | fn bar1(x: &Fn<(), Output=()>) {
    |             ^^^^^^^^^^^^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
-error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead (see issue #29625)
+error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
   --> $DIR/unboxed-closure-sugar-not-used-on-fn.rs:7:28
    |
 LL | fn bar2<T>(x: &T) where T: Fn<()> {
    |                            ^^^^^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29625
    = help: add #![feature(unboxed_closures)] to the crate attributes to enable
 
 error: aborting due to 2 previous errors
diff --git a/src/test/ui/use/use-associated-const.rs b/src/test/ui/use/use-associated-const.rs
new file mode 100644
index 00000000000..714fbdabb81
--- /dev/null
+++ b/src/test/ui/use/use-associated-const.rs
@@ -0,0 +1,13 @@
+#![allow(unused_imports)]
+
+pub mod foo {
+    pub struct Foo;
+
+    impl Foo {
+        pub const BAR: i32 = 0;
+    }
+}
+
+use foo::Foo::BAR; //~ ERROR unresolved import `foo::Foo`
+
+fn main() {}
diff --git a/src/test/ui/use/use-associated-const.stderr b/src/test/ui/use/use-associated-const.stderr
new file mode 100644
index 00000000000..4bc0d7e61cb
--- /dev/null
+++ b/src/test/ui/use/use-associated-const.stderr
@@ -0,0 +1,9 @@
+error[E0432]: unresolved import `foo::Foo`
+  --> $DIR/use-associated-const.rs:11:10
+   |
+LL | use foo::Foo::BAR;
+   |          ^^^ `Foo` is a struct, not a module
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0432`.
diff --git a/src/test/ui/use/use-from-trait-xc.stderr b/src/test/ui/use/use-from-trait-xc.stderr
index 97dc603f9eb..faa4829bfdd 100644
--- a/src/test/ui/use/use-from-trait-xc.stderr
+++ b/src/test/ui/use/use-from-trait-xc.stderr
@@ -20,19 +20,19 @@ error[E0432]: unresolved import `use_from_trait_xc::Foo`
   --> $DIR/use-from-trait-xc.rs:14:24
    |
 LL | use use_from_trait_xc::Foo::new;
-   |                        ^^^ not a module `Foo`
+   |                        ^^^ `Foo` is a struct, not a module
 
 error[E0432]: unresolved import `use_from_trait_xc::Foo`
   --> $DIR/use-from-trait-xc.rs:17:24
    |
 LL | use use_from_trait_xc::Foo::C;
-   |                        ^^^ not a module `Foo`
+   |                        ^^^ `Foo` is a struct, not a module
 
 error[E0432]: unresolved import `use_from_trait_xc::Bar`
   --> $DIR/use-from-trait-xc.rs:20:24
    |
 LL | use use_from_trait_xc::Bar::new as bnew;
-   |                        ^^^ not a module `Bar`
+   |                        ^^^ `Bar` is a struct, not a module
 
 error[E0432]: unresolved import `use_from_trait_xc::Baz::new`
   --> $DIR/use-from-trait-xc.rs:23:5
diff --git a/src/test/ui/use/use-from-trait.rs b/src/test/ui/use/use-from-trait.rs
index fe578723bd3..eab4bb6e3b5 100644
--- a/src/test/ui/use/use-from-trait.rs
+++ b/src/test/ui/use/use-from-trait.rs
@@ -1,17 +1,10 @@
-use Trait::foo;
-//~^ ERROR `foo` is not directly importable
-use Trait::Assoc;
-//~^ ERROR `Assoc` is not directly importable
-use Trait::C;
-//~^ ERROR `C` is not directly importable
+use Trait::foo; //~ ERROR `foo` is not directly importable
+use Trait::Assoc; //~ ERROR `Assoc` is not directly importable
+use Trait::C; //~ ERROR `C` is not directly importable
 
-use Foo::new;
-//~^ ERROR unresolved import `Foo` [E0432]
-//~| not a module `Foo`
+use Foo::new; //~ ERROR unresolved import `Foo` [E0432]
 
-use Foo::C2;
-//~^ ERROR unresolved import `Foo` [E0432]
-//~| not a module `Foo`
+use Foo::C2; //~ ERROR unresolved import `Foo` [E0432]
 
 pub trait Trait {
     fn foo();
diff --git a/src/test/ui/use/use-from-trait.stderr b/src/test/ui/use/use-from-trait.stderr
index 9e138422a2f..af4b3b0c455 100644
--- a/src/test/ui/use/use-from-trait.stderr
+++ b/src/test/ui/use/use-from-trait.stderr
@@ -5,28 +5,28 @@ LL | use Trait::foo;
    |     ^^^^^^^^^^ cannot be imported directly
 
 error[E0253]: `Assoc` is not directly importable
-  --> $DIR/use-from-trait.rs:3:5
+  --> $DIR/use-from-trait.rs:2:5
    |
 LL | use Trait::Assoc;
    |     ^^^^^^^^^^^^ cannot be imported directly
 
 error[E0253]: `C` is not directly importable
-  --> $DIR/use-from-trait.rs:5:5
+  --> $DIR/use-from-trait.rs:3:5
    |
 LL | use Trait::C;
    |     ^^^^^^^^ cannot be imported directly
 
 error[E0432]: unresolved import `Foo`
-  --> $DIR/use-from-trait.rs:8:5
+  --> $DIR/use-from-trait.rs:5:5
    |
 LL | use Foo::new;
-   |     ^^^ not a module `Foo`
+   |     ^^^ `Foo` is a struct, not a module
 
 error[E0432]: unresolved import `Foo`
-  --> $DIR/use-from-trait.rs:12:5
+  --> $DIR/use-from-trait.rs:7:5
    |
 LL | use Foo::C2;
-   |     ^^^ not a module `Foo`
+   |     ^^^ `Foo` is a struct, not a module
 
 error: aborting due to 5 previous errors
 
diff --git a/src/test/ui/utf8_idents.stderr b/src/test/ui/utf8_idents.stderr
index 330ba3e0a8c..b65848cc58f 100644
--- a/src/test/ui/utf8_idents.stderr
+++ b/src/test/ui/utf8_idents.stderr
@@ -1,33 +1,37 @@
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/utf8_idents.rs:2:5
    |
 LL |     'β,
    |     ^^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/utf8_idents.rs:3:5
    |
 LL |     γ
    |     ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/utf8_idents.rs:8:5
    |
 LL |     δ: usize
    |     ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
-error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
+error[E0658]: non-ascii idents are not fully supported
   --> $DIR/utf8_idents.rs:12:9
    |
 LL |     let α = 0.00001f64;
    |         ^
    |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/55467
    = help: add #![feature(non_ascii_idents)] to the crate attributes to enable
 
 warning: type parameter `γ` should have an upper camel case name