diff --git a/Cargo.lock b/Cargo.lock
index c9d1e4e1d386f..c1bf48f704abd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3412,9 +3412,9 @@ checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.5"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+checksum = "8be87abb9e40db7466e0681dc8ecd9dcfd40360cb10b4c8fe24a7c4c3669b198"
 
 [[package]]
 name = "rustc-main"
diff --git a/compiler/rustc_ast/Cargo.toml b/compiler/rustc_ast/Cargo.toml
index 34d90adf5cb3a..471a6bf1df131 100644
--- a/compiler/rustc_ast/Cargo.toml
+++ b/compiler/rustc_ast/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2024"
 # tidy-alphabetical-start
 bitflags = "2.4.1"
 memchr = "2.7.6"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_ast_ir = { path = "../rustc_ast_ir" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 6ecba865c8156..0a2a34d932f61 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -235,6 +235,34 @@ impl AttributeExt for Attribute {
         }
     }
 
+    fn deprecation_note(&self) -> Option<Symbol> {
+        match &self.kind {
+            AttrKind::Normal(normal) if normal.item.path == sym::deprecated => {
+                let meta = &normal.item;
+
+                // #[deprecated = "..."]
+                if let Some(s) = meta.value_str() {
+                    return Some(s);
+                }
+
+                // #[deprecated(note = "...")]
+                if let Some(list) = meta.meta_item_list() {
+                    for nested in list {
+                        if let Some(mi) = nested.meta_item()
+                            && mi.path == sym::note
+                            && let Some(s) = mi.value_str()
+                        {
+                            return Some(s);
+                        }
+                    }
+                }
+
+                None
+            }
+            _ => None,
+        }
+    }
+
     fn doc_resolution_scope(&self) -> Option<AttrStyle> {
         match &self.kind {
             AttrKind::DocComment(..) => Some(self.style),
@@ -277,6 +305,7 @@ impl Attribute {
 
     pub fn may_have_doc_links(&self) -> bool {
         self.doc_str().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
+            || self.deprecation_note().is_some_and(|s| comments::may_have_doc_links(s.as_str()))
     }
 
     /// Extracts the MetaItem from inside this Attribute.
@@ -873,6 +902,11 @@ pub trait AttributeExt: Debug {
     /// * `#[doc(...)]` returns `None`.
     fn doc_str(&self) -> Option<Symbol>;
 
+    /// Returns the deprecation note if this is deprecation attribute.
+    /// * `#[deprecated = "note"]` returns `Some("note")`.
+    /// * `#[deprecated(note = "note", ...)]` returns `Some("note")`.
+    fn deprecation_note(&self) -> Option<Symbol>;
+
     fn is_proc_macro_attr(&self) -> bool {
         [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
             .iter()
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index a81d2297ef85b..fd7c3360b05e3 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2536,6 +2536,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 overly_complex_const(self)
             }
+            ExprKind::Lit(literal) => {
+                let span = expr.span;
+                let literal = self.lower_lit(literal, span);
+
+                ConstArg {
+                    hir_id: self.lower_node_id(expr.id),
+                    kind: hir::ConstArgKind::Literal(literal.node),
+                    span,
+                }
+            }
             _ => overly_complex_const(self),
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
index 41cf92390b0d0..3ce28612ddfcb 100644
--- a/compiler/rustc_codegen_llvm/src/mono_item.rs
+++ b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -10,7 +10,6 @@ use rustc_middle::mir::mono::Visibility;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt};
 use rustc_session::config::CrateType;
-use rustc_span::Symbol;
 use rustc_target::spec::{Arch, RelocModel};
 use tracing::debug;
 
@@ -92,17 +91,19 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
 }
 
 impl CodegenCx<'_, '_> {
-    fn add_aliases(&self, aliasee: &llvm::Value, aliases: &[(Symbol, Linkage, Visibility)]) {
+    fn add_aliases(&self, aliasee: &llvm::Value, aliases: &[(DefId, Linkage, Visibility)]) {
         let ty = self.get_type_of_global(aliasee);
 
         for (alias, linkage, visibility) in aliases {
+            let symbol_name = self.tcx.symbol_name(Instance::mono(self.tcx, *alias));
+
             tracing::debug!("ALIAS: {alias:?} {linkage:?} {visibility:?}");
             let lldecl = llvm::add_alias(
                 self.llmod,
                 ty,
                 AddressSpace::ZERO,
                 aliasee,
-                &CString::new(alias.as_str()).unwrap(),
+                &CString::new(symbol_name.name).unwrap(),
             );
 
             llvm::set_visibility(lldecl, base::visibility_to_llvm(*visibility));
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 94dc3f44a68bf..74f4662118b6d 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -13,10 +13,10 @@ use rustc_middle::middle::codegen_fn_attrs::{
 use rustc_middle::mir::mono::Visibility;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{self as ty, Instance, TyCtxt};
+use rustc_middle::ty::{self as ty, TyCtxt};
 use rustc_session::lint;
 use rustc_session::parse::feature_err;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, sym};
 use rustc_target::spec::Os;
 
 use crate::errors;
@@ -291,8 +291,6 @@ fn process_builtin_attrs(
                         )
                         .expect("eii should have declaration macro with extern target attribute");
 
-                        let symbol_name = tcx.symbol_name(Instance::mono(tcx, extern_item));
-
                         // this is to prevent a bug where a single crate defines both the default and explicit implementation
                         // for an EII. In that case, both of them may be part of the same final object file. I'm not 100% sure
                         // what happens, either rustc deduplicates the symbol or llvm, or it's random/order-dependent.
@@ -310,7 +308,7 @@ fn process_builtin_attrs(
                         }
 
                         codegen_fn_attrs.foreign_item_symbol_aliases.push((
-                            Symbol::intern(symbol_name.name),
+                            extern_item,
                             if i.is_default { Linkage::LinkOnceAny } else { Linkage::External },
                             Visibility::Default,
                         ));
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index aacd6324bb031..d2ea1a15030b6 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -518,6 +518,7 @@ pub enum ConstArgKind<'hir, Unambig = ()> {
     /// This variant is not always used to represent inference consts, sometimes
     /// [`GenericArg::Infer`] is used instead.
     Infer(Unambig),
+    Literal(LitKind),
 }
 
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
@@ -1400,6 +1401,14 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
+    fn deprecation_note(&self) -> Option<Symbol> {
+        match &self {
+            Attribute::Parsed(AttributeKind::Deprecation { deprecation, .. }) => deprecation.note,
+            _ => None,
+        }
+    }
+
     fn is_automatically_derived_attr(&self) -> bool {
         matches!(self, Attribute::Parsed(AttributeKind::AutomaticallyDerived(..)))
     }
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 59db60fdc55c4..e5e6fc7b1d8de 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1104,6 +1104,7 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
         ConstArgKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, qpath.span()),
         ConstArgKind::Anon(anon) => visitor.visit_anon_const(*anon),
         ConstArgKind::Error(_) => V::Result::output(), // errors and spans are not important
+        ConstArgKind::Literal(..) => V::Result::output(), // FIXME(mcga)
     }
 }
 
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 38ae7852ca99f..984a812246eb6 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -79,13 +79,12 @@ impl<'tcx> InherentCollect<'tcx> {
         }
 
         if self.tcx.features().rustc_attrs() {
-            let items = self.tcx.associated_item_def_ids(impl_def_id);
-
             if !self.tcx.has_attr(ty_def_id, sym::rustc_has_incoherent_inherent_impls) {
                 let impl_span = self.tcx.def_span(impl_def_id);
                 return Err(self.tcx.dcx().emit_err(errors::InherentTyOutside { span: impl_span }));
             }
 
+            let items = self.tcx.associated_item_def_ids(impl_def_id);
             for &impl_item in items {
                 if !find_attr!(
                     self.tcx.get_all_attrs(impl_item),
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index aaa566760013c..1dd9bff425759 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -22,6 +22,7 @@ pub mod generics;
 use std::assert_matches::assert_matches;
 use std::slice;
 
+use rustc_ast::LitKind;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
@@ -2391,6 +2392,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             hir::ConstArgKind::Anon(anon) => self.lower_const_arg_anon(anon),
             hir::ConstArgKind::Infer(()) => self.ct_infer(None, const_arg.span),
             hir::ConstArgKind::Error(e) => ty::Const::new_error(tcx, e),
+            hir::ConstArgKind::Literal(kind) if let FeedConstTy::WithTy(anon_const_type) = feed => {
+                self.lower_const_arg_literal(&kind, anon_const_type, const_arg.span)
+            }
+            hir::ConstArgKind::Literal(..) => {
+                let e = self.dcx().span_err(const_arg.span, "literal of unknown type");
+                ty::Const::new_error(tcx, e)
+            }
         }
     }
 
@@ -2773,6 +2781,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
+    #[instrument(skip(self), level = "debug")]
+    fn lower_const_arg_literal(&self, kind: &LitKind, ty: Ty<'tcx>, span: Span) -> Const<'tcx> {
+        let tcx = self.tcx();
+        let input = LitToConstInput { lit: *kind, ty, neg: false };
+        tcx.at(span).lit_to_const(input)
+    }
+
     #[instrument(skip(self), level = "debug")]
     fn try_lower_anon_const_lit(
         &self,
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 2c160ccef2b62..37fa18c00887e 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -21,7 +21,7 @@ use rustc_hir::{
     GenericParam, GenericParamKind, HirId, ImplicitSelfKind, LifetimeParamKind, Node, PatKind,
     PreciseCapturingArg, RangeEnd, Term, TyPatKind,
 };
-use rustc_span::source_map::SourceMap;
+use rustc_span::source_map::{SourceMap, Spanned};
 use rustc_span::{DUMMY_SP, FileName, Ident, Span, Symbol, kw, sym};
 use {rustc_ast as ast, rustc_hir as hir};
 
@@ -1157,6 +1157,10 @@ impl<'a> State<'a> {
             ConstArgKind::Anon(anon) => self.print_anon_const(anon),
             ConstArgKind::Error(_) => self.word("/*ERROR*/"),
             ConstArgKind::Infer(..) => self.word("_"),
+            ConstArgKind::Literal(node) => {
+                let span = const_arg.span;
+                self.print_literal(&Spanned { span, node: *node })
+            }
         }
     }
 
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index d0e8bc50c4957..c85327dc3db19 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1444,6 +1444,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                         | hir::ConstArgKind::TupleCall(..)
                         | hir::ConstArgKind::Tup(..)
                         | hir::ConstArgKind::Path(..)
+                        | hir::ConstArgKind::Literal(..)
                         | hir::ConstArgKind::Infer(..) => true,
                         hir::ConstArgKind::Anon(..) => false,
                     },
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 9033d9c46d543..4f600af0cbfce 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use rustc_abi::Align;
 use rustc_hir::attrs::{InlineAttr, InstructionSetAttr, Linkage, OptimizeAttr, RtsanSetting};
+use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
@@ -72,7 +73,7 @@ pub struct CodegenFnAttrs {
     /// generate this function under its real name,
     /// but *also* under the same name as this foreign function so that the foreign function has an implementation.
     // FIXME: make "SymbolName<'tcx>"
-    pub foreign_item_symbol_aliases: Vec<(Symbol, Linkage, Visibility)>,
+    pub foreign_item_symbol_aliases: Vec<(DefId, Linkage, Visibility)>,
     /// The `#[link_ordinal = "..."]` attribute, indicating an ordinal an
     /// imported function has in the dynamic library. Note that this must not
     /// be set when `link_name` is set. This is for foreign items with the
diff --git a/compiler/rustc_parse/Cargo.toml b/compiler/rustc_parse/Cargo.toml
index 04a51c9056610..f0c84e07a56ff 100644
--- a/compiler/rustc_parse/Cargo.toml
+++ b/compiler/rustc_parse/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 bitflags = "2.4.1"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
diff --git a/compiler/rustc_parse_format/Cargo.toml b/compiler/rustc_parse_format/Cargo.toml
index d178fcda1fb9f..10b41a39c3bf2 100644
--- a/compiler/rustc_parse_format/Cargo.toml
+++ b/compiler/rustc_parse_format/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 rustc_lexer = { path = "../rustc_lexer" }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_proc_macro/Cargo.toml b/compiler/rustc_proc_macro/Cargo.toml
index beb95aa3b52f2..54c765075113e 100644
--- a/compiler/rustc_proc_macro/Cargo.toml
+++ b/compiler/rustc_proc_macro/Cargo.toml
@@ -16,7 +16,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_resolve/src/rustdoc.rs b/compiler/rustc_resolve/src/rustdoc.rs
index 7f7c423acb40a..9f74a7801d2ee 100644
--- a/compiler/rustc_resolve/src/rustdoc.rs
+++ b/compiler/rustc_resolve/src/rustdoc.rs
@@ -410,8 +410,17 @@ pub fn may_be_doc_link(link_type: LinkType) -> bool {
 /// Simplified version of `preprocessed_markdown_links` from rustdoc.
 /// Must return at least the same links as it, but may add some more links on top of that.
 pub(crate) fn attrs_to_preprocessed_links<A: AttributeExt + Clone>(attrs: &[A]) -> Vec<Box<str>> {
-    let (doc_fragments, _) = attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), true);
-    let doc = prepare_to_doc_link_resolution(&doc_fragments).into_values().next().unwrap();
+    let (doc_fragments, other_attrs) =
+        attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), false);
+    let mut doc =
+        prepare_to_doc_link_resolution(&doc_fragments).into_values().next().unwrap_or_default();
+
+    for attr in other_attrs {
+        if let Some(note) = attr.deprecation_note() {
+            doc += note.as_str();
+            doc += "\n";
+        }
+    }
 
     parse_links(&doc)
 }
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 092d99e911188..6faa57252ca2a 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -381,15 +381,14 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
     pub fn new(
         cx: &impl HasDataLayout,
         layout: TyAndLayout<'a, Ty>,
-        scalar_attrs: impl Fn(&TyAndLayout<'a, Ty>, Scalar, Size) -> ArgAttributes,
+        scalar_attrs: impl Fn(Scalar, Size) -> ArgAttributes,
     ) -> Self {
         let mode = match layout.backend_repr {
-            BackendRepr::Scalar(scalar) => {
-                PassMode::Direct(scalar_attrs(&layout, scalar, Size::ZERO))
-            }
+            _ if layout.is_zst() => PassMode::Ignore,
+            BackendRepr::Scalar(scalar) => PassMode::Direct(scalar_attrs(scalar, Size::ZERO)),
             BackendRepr::ScalarPair(a, b) => PassMode::Pair(
-                scalar_attrs(&layout, a, Size::ZERO),
-                scalar_attrs(&layout, b, a.size(cx).align_to(b.align(cx).abi)),
+                scalar_attrs(a, Size::ZERO),
+                scalar_attrs(b, a.size(cx).align_to(b.align(cx).abi)),
             ),
             BackendRepr::SimdVector { .. } => PassMode::Direct(ArgAttributes::new()),
             BackendRepr::Memory { .. } => Self::indirect_pass_mode(&layout),
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 0676fa99d826d..ad621c67772cc 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -549,15 +549,9 @@ fn fn_abi_new_uncached<'tcx>(
             layout
         };
 
-        let mut arg = ArgAbi::new(cx, layout, |layout, scalar, offset| {
-            arg_attrs_for_rust_scalar(*cx, scalar, *layout, offset, is_return, drop_target_pointee)
-        });
-
-        if arg.layout.is_zst() {
-            arg.mode = PassMode::Ignore;
-        }
-
-        Ok(arg)
+        Ok(ArgAbi::new(cx, layout, |scalar, offset| {
+            arg_attrs_for_rust_scalar(*cx, scalar, layout, offset, is_return, drop_target_pointee)
+        }))
     };
 
     let mut fn_abi = FnAbi {
diff --git a/library/Cargo.lock b/library/Cargo.lock
index 5e49843dae062..f6c14bc58a044 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -283,12 +283,11 @@ dependencies = [
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.5"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+checksum = "8be87abb9e40db7466e0681dc8ecd9dcfd40360cb10b4c8fe24a7c4c3669b198"
 dependencies = [
  "rustc-std-workspace-core",
- "rustc-std-workspace-std",
 ]
 
 [[package]]
diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 38995cf0f0ff0..699a9c417ddef 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -203,7 +203,7 @@ jobs:
     # Unlike rustfmt, stable clippy does not work on code with nightly features.
     - name: Install nightly `clippy`
       run: |
-        rustup set profile minimal
+        rustup update nightly --no-self-update
         rustup default nightly
         rustup component add clippy
     - uses: Swatinem/rust-cache@v2
@@ -247,16 +247,7 @@ jobs:
     - uses: taiki-e/install-action@cargo-binstall
 
     - name: Set up dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y valgrind gdb libc6-dbg # Needed for gungraun
-        rustup update "$BENCHMARK_RUSTC" --no-self-update
-        rustup default "$BENCHMARK_RUSTC"
-        # Install the version of gungraun-runner that is specified in Cargo.toml
-        gungraun_version="$(cargo metadata --format-version=1 --features icount |
-           jq -r '.packages[] | select(.name == "gungraun").version')"
-        cargo binstall -y gungraun-runner --version "$gungraun_version"
-        sudo apt-get install valgrind
+      run: ./ci/install-bench-deps.sh
     - uses: Swatinem/rust-cache@v2
       with:
         key: ${{ matrix.target }}
@@ -276,13 +267,7 @@ jobs:
         path: ${{ env.BASELINE_NAME }}.tar.xz
 
     - name: Run wall time benchmarks
-      run: |
-        # Always use the same seed for benchmarks. Ideally we should switch to a
-        # non-random generator.
-        export LIBM_SEED=benchesbenchesbenchesbencheswoo!
-        cargo bench --package libm-test \
-          --no-default-features \
-          --features short-benchmarks,build-musl,libm/force-soft-floats
+      run: ./ci/bench-runtime.sh
 
     - name: Print test logs if available
       if: always()
diff --git a/library/compiler-builtins/ci/bench-runtime.sh b/library/compiler-builtins/ci/bench-runtime.sh
new file mode 100755
index 0000000000000..d272cf33463ed
--- /dev/null
+++ b/library/compiler-builtins/ci/bench-runtime.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+# Run wall time benchmarks as we do on CI.
+
+# Always use the same seed for benchmarks. Ideally we should switch to a
+# non-random generator.
+export LIBM_SEED=benchesbenchesbenchesbencheswoo!
+cargo bench --package libm-test \
+    --no-default-features \
+    --features short-benchmarks,build-musl,libm/force-soft-floats
diff --git a/library/compiler-builtins/ci/install-bench-deps.sh b/library/compiler-builtins/ci/install-bench-deps.sh
new file mode 100755
index 0000000000000..61f4723c0358d
--- /dev/null
+++ b/library/compiler-builtins/ci/install-bench-deps.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+# Install needed dependencies for gungraun.
+
+sudo apt-get update
+sudo apt-get install -y valgrind gdb libc6-dbg # Needed for gungraun
+rustup update "$BENCHMARK_RUSTC" --no-self-update
+rustup default "$BENCHMARK_RUSTC"
+# Install the version of gungraun-runner that is specified in Cargo.toml
+gungraun_version="$(cargo metadata --format-version=1 --features icount |
+    jq -r '.packages[] | select(.name == "gungraun").version')"
+cargo binstall -y gungraun-runner --version "$gungraun_version"
diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64.rs b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
index 039fab2061c5f..1b230a214eefe 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
@@ -4,7 +4,7 @@ use core::intrinsics;
 
 intrinsics! {
     #[unsafe(naked)]
-    #[cfg(target_os = "uefi")]
+    #[cfg(any(all(windows, target_env = "gnu"), target_os = "uefi"))]
     pub unsafe extern "custom" fn __chkstk() {
         core::arch::naked_asm!(
             ".p2align 2",
diff --git a/library/compiler-builtins/libm/src/libm_helper.rs b/library/compiler-builtins/libm/src/libm_helper.rs
index dfa1ff77bf2e4..0bb669398657e 100644
--- a/library/compiler-builtins/libm/src/libm_helper.rs
+++ b/library/compiler-builtins/libm/src/libm_helper.rs
@@ -168,7 +168,7 @@ libm_helper! {
         (fn remquo(x: f64, y: f64) -> (f64, i32);   => remquo);
         (fn rint(x: f64) -> (f64);                  => rint);
         (fn round(x: f64) -> (f64);                 => round);
-        (fn roundevem(x: f64) -> (f64);             => roundeven);
+        (fn roundeven(x: f64) -> (f64);             => roundeven);
         (fn scalbn(x: f64, n: i32) -> (f64);        => scalbn);
         (fn sin(x: f64) -> (f64);                   => sin);
         (fn sincos(x: f64) -> (f64, f64);           => sincos);
diff --git a/library/compiler-builtins/libm/src/math/arch/x86/detect.rs b/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
index 5391a68228edd..ca785470b806d 100644
--- a/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
+++ b/library/compiler-builtins/libm/src/math/arch/x86/detect.rs
@@ -39,6 +39,8 @@ pub fn get_cpu_features() -> Flags {
 /// Implementation is taken from [std-detect][std-detect].
 ///
 /// [std-detect]: https://github.com/rust-lang/stdarch/blob/690b3a6334d482874163bd6fcef408e0518febe9/crates/std_detect/src/detect/os/x86.rs#L142
+// FIXME(msrv): Remove unsafe block around __cpuid once https://github.com/rust-lang/stdarch/pull/1935 is available in MSRV.
+#[allow(unused_unsafe)]
 fn load_x86_features() -> Flags {
     let mut value = Flags::empty();
 
@@ -57,7 +59,7 @@ fn load_x86_features() -> Flags {
     //   (in that order)
     let mut vendor_id = [0u8; 12];
     let max_basic_leaf;
-    {
+    unsafe {
         let CpuidResult { eax, ebx, ecx, edx } = __cpuid(0);
         max_basic_leaf = eax;
         vendor_id[0..4].copy_from_slice(&ebx.to_ne_bytes());
@@ -72,7 +74,7 @@ fn load_x86_features() -> Flags {
 
     // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
     // Contains information about most x86 features.
-    let CpuidResult { ecx, edx, .. } = __cpuid(0x0000_0001_u32);
+    let CpuidResult { ecx, edx, .. } = unsafe { __cpuid(0x0000_0001_u32) };
     let proc_info_ecx = Flags::from_bits(ecx);
     let proc_info_edx = Flags::from_bits(edx);
 
@@ -82,23 +84,23 @@ fn load_x86_features() -> Flags {
     let mut extended_features_edx = Flags::empty();
     let mut extended_features_eax_leaf_1 = Flags::empty();
     if max_basic_leaf >= 7 {
-        let CpuidResult { ebx, edx, .. } = __cpuid(0x0000_0007_u32);
+        let CpuidResult { ebx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
         extended_features_ebx = Flags::from_bits(ebx);
         extended_features_edx = Flags::from_bits(edx);
 
-        let CpuidResult { eax, .. } = __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32);
+        let CpuidResult { eax, .. } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
         extended_features_eax_leaf_1 = Flags::from_bits(eax)
     }
 
     // EAX = 0x8000_0000, ECX = 0: Get Highest Extended Function Supported
     // - EAX returns the max leaf value for extended information, that is,
     //   `cpuid` calls in range [0x8000_0000; u32::MAX]:
-    let extended_max_basic_leaf = __cpuid(0x8000_0000_u32).eax;
+    let extended_max_basic_leaf = unsafe { __cpuid(0x8000_0000_u32) }.eax;
 
     // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature Bits"
     let mut extended_proc_info_ecx = Flags::empty();
     if extended_max_basic_leaf >= 1 {
-        let CpuidResult { ecx, .. } = __cpuid(0x8000_0001_u32);
+        let CpuidResult { ecx, .. } = unsafe { __cpuid(0x8000_0001_u32) };
         extended_proc_info_ecx = Flags::from_bits(ecx);
     }
 
diff --git a/library/compiler-builtins/rust-version b/library/compiler-builtins/rust-version
index 7345c25066a82..6a2835bc2d9eb 100644
--- a/library/compiler-builtins/rust-version
+++ b/library/compiler-builtins/rust-version
@@ -1 +1 @@
-2dc30247c5d8293aaa31e1d7dae2ed2fde908ada
+23d01cd2412583491621ab1ca4f1b01e37d11e39
diff --git a/library/proc_macro/Cargo.toml b/library/proc_macro/Cargo.toml
index 3a4840a57334b..1e5046ca61c39 100644
--- a/library/proc_macro/Cargo.toml
+++ b/library/proc_macro/Cargo.toml
@@ -9,7 +9,7 @@ std = { path = "../std" }
 # `core` when resolving doc links. Without this line a different `core` will be
 # loaded from sysroot causing duplicate lang items and other similar errors.
 core = { path = "../core" }
-rustc-literal-escaper = { version = "0.0.5", features = ["rustc-dep-of-std"] }
+rustc-literal-escaper = { version = "0.0.7", features = ["rustc-dep-of-std"] }
 
 [features]
 default = ["rustc-dep-of-std"]
diff --git a/library/std/src/os/fd/owned.rs b/library/std/src/os/fd/owned.rs
index 2acac6f086e43..8a39fe073bf95 100644
--- a/library/std/src/os/fd/owned.rs
+++ b/library/std/src/os/fd/owned.rs
@@ -77,7 +77,11 @@ impl BorrowedFd<'_> {
     /// # Safety
     ///
     /// The resource pointed to by `fd` must remain open for the duration of
-    /// the returned `BorrowedFd`, and it must not have the value `-1`.
+    /// the returned `BorrowedFd`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the raw file descriptor has the value `-1`.
     #[inline]
     #[track_caller]
     #[rustc_const_stable(feature = "io_safety", since = "1.63.0")]
@@ -177,6 +181,10 @@ impl FromRawFd for OwnedFd {
     /// [ownership][io-safety]. The resource must not require any cleanup other than `close`.
     ///
     /// [io-safety]: io#io-safety
+    ///
+    /// # Panics
+    ///
+    /// Panics if the raw file descriptor has the value `-1`.
     #[inline]
     #[track_caller]
     unsafe fn from_raw_fd(fd: RawFd) -> Self {
diff --git a/library/std/src/sys/fs/uefi.rs b/library/std/src/sys/fs/uefi.rs
index 74cacd6caff7f..17e98128b050b 100644
--- a/library/std/src/sys/fs/uefi.rs
+++ b/library/std/src/sys/fs/uefi.rs
@@ -6,7 +6,7 @@ use crate::fs::TryLockError;
 use crate::hash::Hash;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::path::{Path, PathBuf};
-pub use crate::sys::fs::common::Dir;
+pub use crate::sys::fs::common::{Dir, remove_dir_all};
 use crate::sys::pal::{helpers, unsupported};
 use crate::sys::time::SystemTime;
 
@@ -481,10 +481,6 @@ pub fn rmdir(p: &Path) -> io::Result<()> {
     }
 }
 
-pub fn remove_dir_all(_path: &Path) -> io::Result<()> {
-    unsupported()
-}
-
 pub fn exists(path: &Path) -> io::Result<bool> {
     let f = uefi_fs::File::from_path(path, r_efi::protocols::file::MODE_READ, 0);
     match f {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index e05d3e4164306..817eda4c52ecc 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -332,6 +332,9 @@ pub(crate) fn clean_const<'tcx>(constant: &hir::ConstArg<'tcx>) -> ConstantKind
         }
         hir::ConstArgKind::Anon(anon) => ConstantKind::Anonymous { body: anon.body },
         hir::ConstArgKind::Infer(..) | hir::ConstArgKind::Error(..) => ConstantKind::Infer,
+        hir::ConstArgKind::Literal(..) => {
+            ConstantKind::Path { path: "/* LITERAL */".to_string().into() }
+        }
     }
 }
 
@@ -1814,7 +1817,8 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
                 hir::ConstArgKind::Struct(..)
                 | hir::ConstArgKind::Path(..)
                 | hir::ConstArgKind::TupleCall(..)
-                | hir::ConstArgKind::Tup(..) => {
+                | hir::ConstArgKind::Tup(..)
+                | hir::ConstArgKind::Literal(..) => {
                     let ct = lower_const_arg_for_rustdoc(cx.tcx, const_arg, FeedConstTy::No);
                     print_const(cx, ct)
                 }
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index a390a03ff1144..c3bafd3db13ac 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -7,6 +7,7 @@ use std::{fmt, iter};
 use arrayvec::ArrayVec;
 use itertools::Either;
 use rustc_abi::{ExternAbi, VariantIdx};
+use rustc_ast::attr::AttributeExt;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation, DocAttribute};
@@ -450,7 +451,16 @@ impl Item {
     }
 
     pub(crate) fn attr_span(&self, tcx: TyCtxt<'_>) -> rustc_span::Span {
+        let deprecation_notes = self
+            .attrs
+            .other_attrs
+            .iter()
+            .filter_map(|attr| attr.deprecation_note().map(|_| attr.span()));
+
         span_of_fragments(&self.attrs.doc_strings)
+            .into_iter()
+            .chain(deprecation_notes)
+            .reduce(|a, b| a.to(b))
             .unwrap_or_else(|| self.span(tcx).map_or(DUMMY_SP, |span| span.inner()))
     }
 
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index a4d377432c914..c472c20a7dc71 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -111,7 +111,11 @@ pub(crate) struct MarkdownWithToc<'a> {
 }
 /// A tuple struct like `Markdown` that renders the markdown escaping HTML tags
 /// and includes no paragraph tags.
-pub(crate) struct MarkdownItemInfo<'a>(pub(crate) &'a str, pub(crate) &'a mut IdMap);
+pub(crate) struct MarkdownItemInfo<'a> {
+    pub(crate) content: &'a str,
+    pub(crate) links: &'a [RenderedLink],
+    pub(crate) ids: &'a mut IdMap,
+}
 /// A tuple struct like `Markdown` that renders only the first paragraph.
 pub(crate) struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
 
@@ -1459,15 +1463,28 @@ impl MarkdownWithToc<'_> {
     }
 }
 
-impl MarkdownItemInfo<'_> {
+impl<'a> MarkdownItemInfo<'a> {
+    pub(crate) fn new(content: &'a str, links: &'a [RenderedLink], ids: &'a mut IdMap) -> Self {
+        Self { content, links, ids }
+    }
+
     pub(crate) fn write_into(self, mut f: impl fmt::Write) -> fmt::Result {
-        let MarkdownItemInfo(md, ids) = self;
+        let MarkdownItemInfo { content: md, links, ids } = self;
 
         // This is actually common enough to special-case
         if md.is_empty() {
             return Ok(());
         }
-        let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
+
+        let replacer = move |broken_link: BrokenLink<'_>| {
+            links
+                .iter()
+                .find(|link| *link.original_text == *broken_link.reference)
+                .map(|link| (link.href.as_str().into(), link.tooltip.as_str().into()))
+        };
+
+        let p = Parser::new_with_broken_link_callback(md, main_body_opts(), Some(replacer));
+        let p = p.into_offset_iter();
 
         // Treat inline HTML as plain text.
         let p = p.map(|event| match event.0 {
@@ -1477,6 +1494,7 @@ impl MarkdownItemInfo<'_> {
 
         ids.handle_footnotes(|ids, existing_footnotes| {
             let p = HeadingLinks::new(p, None, ids, HeadingOffset::H1);
+            let p = SpannedLinkReplacer::new(p, links);
             let p = footnotes::Footnotes::new(p, existing_footnotes);
             let p = TableWrapper::new(p.map(|(ev, _)| ev));
             let p = p.filter(|event| {
diff --git a/src/librustdoc/html/markdown/tests.rs b/src/librustdoc/html/markdown/tests.rs
index 61fd428746332..1c99ccc5228b1 100644
--- a/src/librustdoc/html/markdown/tests.rs
+++ b/src/librustdoc/html/markdown/tests.rs
@@ -471,7 +471,7 @@ fn test_markdown_html_escape() {
     fn t(input: &str, expect: &str) {
         let mut idmap = IdMap::new();
         let mut output = String::new();
-        MarkdownItemInfo(input, &mut idmap).write_into(&mut output).unwrap();
+        MarkdownItemInfo::new(input, &[], &mut idmap).write_into(&mut output).unwrap();
         assert_eq!(output, expect, "original: {}", input);
     }
 
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 4529f5a8c0163..63de870f07f45 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -877,7 +877,8 @@ fn short_item_info(
         if let Some(note) = note {
             let note = note.as_str();
             let mut id_map = cx.id_map.borrow_mut();
-            let html = MarkdownItemInfo(note, &mut id_map);
+            let links = item.links(cx);
+            let html = MarkdownItemInfo::new(note, &links, &mut id_map);
             message.push_str(": ");
             html.write_into(&mut message).unwrap();
         }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 3abf0fee3959a..07d6efaa97e15 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -7,6 +7,7 @@ use std::fmt::Display;
 use std::mem;
 use std::ops::Range;
 
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::util::comments::may_have_doc_links;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
@@ -1047,18 +1048,7 @@ impl LinkCollector<'_, '_> {
             return;
         }
 
-        // We want to resolve in the lexical scope of the documentation.
-        // In the presence of re-exports, this is not the same as the module of the item.
-        // Rather than merging all documentation into one, resolve it one attribute at a time
-        // so we know which module it came from.
-        for (item_id, doc) in prepare_to_doc_link_resolution(&item.attrs.doc_strings) {
-            if !may_have_doc_links(&doc) {
-                continue;
-            }
-            debug!("combined_docs={doc}");
-            // NOTE: if there are links that start in one crate and end in another, this will not resolve them.
-            // This is a degenerate case and it's not supported by rustdoc.
-            let item_id = item_id.unwrap_or_else(|| item.item_id.expect_def_id());
+        let mut insert_links = |item_id, doc: &str| {
             let module_id = match self.cx.tcx.def_kind(item_id) {
                 DefKind::Mod if item.inner_docs(self.cx.tcx) => item_id,
                 _ => find_nearest_parent_module(self.cx.tcx, item_id).unwrap(),
@@ -1074,6 +1064,35 @@ impl LinkCollector<'_, '_> {
                         .insert(link);
                 }
             }
+        };
+
+        // We want to resolve in the lexical scope of the documentation.
+        // In the presence of re-exports, this is not the same as the module of the item.
+        // Rather than merging all documentation into one, resolve it one attribute at a time
+        // so we know which module it came from.
+        for (item_id, doc) in prepare_to_doc_link_resolution(&item.attrs.doc_strings) {
+            if !may_have_doc_links(&doc) {
+                continue;
+            }
+
+            debug!("combined_docs={doc}");
+            // NOTE: if there are links that start in one crate and end in another, this will not resolve them.
+            // This is a degenerate case and it's not supported by rustdoc.
+            let item_id = item_id.unwrap_or_else(|| item.item_id.expect_def_id());
+            insert_links(item_id, &doc)
+        }
+
+        // Also resolve links in the note text of `#[deprecated]`.
+        for attr in &item.attrs.other_attrs {
+            let Some(note_sym) = attr.deprecation_note() else { continue };
+            let note = note_sym.as_str();
+
+            if !may_have_doc_links(note) {
+                continue;
+            }
+
+            debug!("deprecated_note={note}");
+            insert_links(item.item_id.expect_def_id(), note)
         }
     }
 
@@ -1086,7 +1105,7 @@ impl LinkCollector<'_, '_> {
     /// FIXME(jynelson): this is way too many arguments
     fn resolve_link(
         &mut self,
-        dox: &String,
+        dox: &str,
         item: &Item,
         item_id: DefId,
         module_id: DefId,
diff --git a/src/tools/clippy/clippy_dev/Cargo.toml b/src/tools/clippy/clippy_dev/Cargo.toml
index c2abbac375354..238465210ee28 100644
--- a/src/tools/clippy/clippy_dev/Cargo.toml
+++ b/src/tools/clippy/clippy_dev/Cargo.toml
@@ -10,7 +10,7 @@ clap = { version = "4.4", features = ["derive"] }
 indoc = "1.0"
 itertools = "0.12"
 opener = "0.7"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 walkdir = "2.3"
 
 [package.metadata.rust-analyzer]
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index 455f76edc9047..7a54ba7a8fe10 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -324,6 +324,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             ConstArgKind::Tup(..) => chain!(self, "let ConstArgKind::Tup(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
+            ConstArgKind::Literal(..) => chain!(self, "let ConstArgKind::Literal(..) = {const_arg}.kind")
         }
     }
 
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
index 46b87fd5df961..5f4b87590dc1e 100644
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -1140,7 +1140,7 @@ pub fn const_item_rhs_to_expr<'tcx>(tcx: TyCtxt<'tcx>, ct_rhs: ConstItemRhs<'tcx
         ConstItemRhs::Body(body_id) => Some(tcx.hir_body(body_id).value),
         ConstItemRhs::TypeConst(const_arg) => match const_arg.kind {
             ConstArgKind::Anon(anon) => Some(tcx.hir_body(anon.body).value),
-            ConstArgKind::Struct(..) | ConstArgKind::TupleCall(..) | ConstArgKind::Tup(..) | ConstArgKind::Path(_) | ConstArgKind::Error(..) | ConstArgKind::Infer(..) => {
+            ConstArgKind::Struct(..) | ConstArgKind::TupleCall(..) | ConstArgKind::Tup(..) | ConstArgKind::Path(_) | ConstArgKind::Error(..) | ConstArgKind::Infer(..) | ConstArgKind::Literal(..) => {
                 None
             },
         },
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 57c896c971722..b4e483ea80729 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -689,6 +689,9 @@ impl HirEqInterExpr<'_, '_, '_> {
                     .zip(*args_b)
                     .all(|(arg_a, arg_b)| self.eq_const_arg(arg_a, arg_b))
             }
+            (ConstArgKind::Literal(kind_l), ConstArgKind::Literal(kind_r)) => {
+                kind_l == kind_r
+            },
             // Use explicit match for now since ConstArg is undergoing flux.
             (
                 ConstArgKind::Path(..)
@@ -697,6 +700,7 @@ impl HirEqInterExpr<'_, '_, '_> {
                 | ConstArgKind::Tup(..)
                 | ConstArgKind::Infer(..)
                 | ConstArgKind::Struct(..)
+                | ConstArgKind::Literal(..)
                 | ConstArgKind::Error(..),
                 _,
             ) => false,
@@ -1577,6 +1581,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 }
             },
             ConstArgKind::Infer(..) | ConstArgKind::Error(..) => {},
+            ConstArgKind::Literal(lit) => lit.hash(&mut self.s)
         }
     }
 
diff --git a/src/tools/lint-docs/Cargo.toml b/src/tools/lint-docs/Cargo.toml
index 6e1ab84ed18d9..ab99eb8ea3b72 100644
--- a/src/tools/lint-docs/Cargo.toml
+++ b/src/tools/lint-docs/Cargo.toml
@@ -7,7 +7,7 @@ description = "A script to extract the lint documentation for the rustc book."
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.7"
 serde_json = "1.0.57"
 tempfile = "3.1.0"
 walkdir = "2.3.1"
diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index a45af7fcf1580..1c81a485608ae 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -21,13 +21,18 @@ use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str::FromStr;
-use std::{fmt, fs, io};
+use std::{env, fmt, fs, io};
+
+use build_helper::ci::CiEnv;
 
 use crate::CiInfo;
 use crate::diagnostics::TidyCtx;
 
 mod rustdoc_js;
 
+#[cfg(test)]
+mod tests;
+
 const MIN_PY_REV: (u32, u32) = (3, 9);
 const MIN_PY_REV_STR: &str = "≥3.9";
 
@@ -43,6 +48,7 @@ const RUFF_CACHE_PATH: &[&str] = &["cache", "ruff_cache"];
 const PIP_REQ_PATH: &[&str] = &["src", "tools", "tidy", "config", "requirements.txt"];
 
 const SPELLCHECK_DIRS: &[&str] = &["compiler", "library", "src/bootstrap", "src/librustdoc"];
+const SPELLCHECK_VER: &str = "1.38.1";
 
 pub fn check(
     root_path: &Path,
@@ -115,6 +121,7 @@ fn check_impl(
             .collect(),
         None => vec![],
     };
+    lint_args.retain(|ck| ck.is_non_if_installed_or_matches(root_path, outdir));
     if lint_args.iter().any(|ck| ck.auto) {
         crate::files_modified_batch_filter(ci_info, &mut lint_args, |ck, path| {
             ck.is_non_auto_or_matches(path)
@@ -421,21 +428,11 @@ fn py_runner(
 /// Create a virtuaenv at a given path if it doesn't already exist, or validate
 /// the install if it does. Returns the path to that venv's python executable.
 fn get_or_create_venv(venv_path: &Path, src_reqs_path: &Path) -> Result<PathBuf, Error> {
-    let mut should_create = true;
-    let dst_reqs_path = venv_path.join("requirements.txt");
     let mut py_path = venv_path.to_owned();
     py_path.extend(REL_PY_PATH);
 
-    if let Ok(req) = fs::read_to_string(&dst_reqs_path) {
-        if req == fs::read_to_string(src_reqs_path)? {
-            // found existing environment
-            should_create = false;
-        } else {
-            eprintln!("requirements.txt file mismatch, recreating environment");
-        }
-    }
-
-    if should_create {
+    if !has_py_tools(venv_path, src_reqs_path)? {
+        let dst_reqs_path = venv_path.join("requirements.txt");
         eprintln!("removing old virtual environment");
         if venv_path.is_dir() {
             fs::remove_dir_all(venv_path).unwrap_or_else(|_| {
@@ -450,6 +447,18 @@ fn get_or_create_venv(venv_path: &Path, src_reqs_path: &Path) -> Result<PathBuf,
     Ok(py_path)
 }
 
+fn has_py_tools(venv_path: &Path, src_reqs_path: &Path) -> Result<bool, Error> {
+    let dst_reqs_path = venv_path.join("requirements.txt");
+    if let Ok(req) = fs::read_to_string(&dst_reqs_path) {
+        if req == fs::read_to_string(src_reqs_path)? {
+            return Ok(true);
+        }
+        eprintln!("requirements.txt file mismatch");
+    }
+
+    Ok(false)
+}
+
 /// Attempt to create a virtualenv at this path. Cycles through all expected
 /// valid python versions to find one that is installed.
 fn create_venv_at_path(path: &Path) -> Result<(), Error> {
@@ -591,23 +600,26 @@ fn install_requirements(
     Ok(())
 }
 
-/// Check that shellcheck is installed then run it at the given path
-fn shellcheck_runner(args: &[&OsStr]) -> Result<(), Error> {
+/// Returns `Ok` if shellcheck is installed, `Err` otherwise.
+fn has_shellcheck() -> Result<(), Error> {
     match Command::new("shellcheck").arg("--version").status() {
-        Ok(_) => (),
-        Err(e) if e.kind() == io::ErrorKind::NotFound => {
-            return Err(Error::MissingReq(
-                "shellcheck",
-                "shell file checks",
-                Some(
-                    "see <https://github.com/koalaman/shellcheck#installing> \
-                    for installation instructions"
-                        .to_owned(),
-                ),
-            ));
-        }
-        Err(e) => return Err(e.into()),
+        Ok(_) => Ok(()),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Err(Error::MissingReq(
+            "shellcheck",
+            "shell file checks",
+            Some(
+                "see <https://github.com/koalaman/shellcheck#installing> \
+                for installation instructions"
+                    .to_owned(),
+            ),
+        )),
+        Err(e) => Err(e.into()),
     }
+}
+
+/// Check that shellcheck is installed then run it at the given path
+fn shellcheck_runner(args: &[&OsStr]) -> Result<(), Error> {
+    has_shellcheck()?;
 
     let status = Command::new("shellcheck").args(args).status()?;
     if status.success() { Ok(()) } else { Err(Error::FailedCheck("shellcheck")) }
@@ -621,7 +633,7 @@ fn spellcheck_runner(
     args: &[&str],
 ) -> Result<(), Error> {
     let bin_path =
-        crate::ensure_version_or_cargo_install(outdir, cargo, "typos-cli", "typos", "1.38.1")?;
+        ensure_version_or_cargo_install(outdir, cargo, "typos-cli", "typos", SPELLCHECK_VER)?;
     match Command::new(bin_path).current_dir(src_root).args(args).status() {
         Ok(status) => {
             if status.success() {
@@ -675,6 +687,83 @@ fn find_with_extension(
     Ok(output)
 }
 
+/// Check if the given executable is installed and the version is expected.
+fn ensure_version(build_dir: &Path, bin_name: &str, version: &str) -> Result<PathBuf, Error> {
+    let bin_path = build_dir.join("misc-tools").join("bin").join(bin_name);
+
+    match Command::new(&bin_path).arg("--version").output() {
+        Ok(output) => {
+            let Some(v) = str::from_utf8(&output.stdout).unwrap().trim().split_whitespace().last()
+            else {
+                return Err(Error::Generic("version check failed".to_string()));
+            };
+
+            if v != version {
+                return Err(Error::Version { program: "", required: "", installed: v.to_string() });
+            }
+            Ok(bin_path)
+        }
+        Err(e) => Err(Error::Io(e)),
+    }
+}
+
+/// If the given executable is installed with the given version, use that,
+/// otherwise install via cargo.
+fn ensure_version_or_cargo_install(
+    build_dir: &Path,
+    cargo: &Path,
+    pkg_name: &str,
+    bin_name: &str,
+    version: &str,
+) -> Result<PathBuf, Error> {
+    if let Ok(bin_path) = ensure_version(build_dir, bin_name, version) {
+        return Ok(bin_path);
+    }
+
+    eprintln!("building external tool {bin_name} from package {pkg_name}@{version}");
+
+    let tool_root_dir = build_dir.join("misc-tools");
+    let tool_bin_dir = tool_root_dir.join("bin");
+    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
+
+    // use --force to ensure that if the required version is bumped, we update it.
+    // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
+    // modify PATH so that cargo doesn't print a warning telling the user to modify the path.
+    let mut cmd = Command::new(cargo);
+    cmd.args(["install", "--locked", "--force", "--quiet"])
+        .arg("--root")
+        .arg(&tool_root_dir)
+        .arg("--target-dir")
+        .arg(tool_root_dir.join("target"))
+        .arg(format!("{pkg_name}@{version}"))
+        .env(
+            "PATH",
+            env::join_paths(
+                env::split_paths(&env::var("PATH").unwrap())
+                    .chain(std::iter::once(tool_bin_dir.clone())),
+            )
+            .expect("build dir contains invalid char"),
+        );
+
+    // On CI, we set opt-level flag for quicker installation.
+    // Since lower opt-level decreases the tool's performance,
+    // we don't set this option on local.
+    if CiEnv::is_ci() {
+        cmd.env("RUSTFLAGS", "-Copt-level=0");
+    }
+
+    let cargo_exit_code = cmd.spawn()?.wait()?;
+    if !cargo_exit_code.success() {
+        return Err(Error::Generic("cargo install failed".to_string()));
+    }
+    assert!(
+        matches!(bin_path.try_exists(), Ok(true)),
+        "cargo install did not produce the expected binary"
+    );
+    eprintln!("finished building tool {bin_name}");
+    Ok(bin_path)
+}
+
 #[derive(Debug)]
 enum Error {
     Io(io::Error),
@@ -723,7 +812,7 @@ impl From<io::Error> for Error {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 enum ExtraCheckParseError {
     #[allow(dead_code, reason = "shown through Debug")]
     UnknownKind(String),
@@ -736,10 +825,16 @@ enum ExtraCheckParseError {
     Empty,
     /// `auto` specified without lang part.
     AutoRequiresLang,
+    /// `if-installed` specified without lang part.
+    IfInstalledRequiresLang,
 }
 
+#[derive(PartialEq, Debug)]
 struct ExtraCheckArg {
+    /// Only run the check if files to check have been modified.
     auto: bool,
+    /// Only run the check if the requisite software is already installed.
+    if_installed: bool,
     lang: ExtraCheckLang,
     /// None = run all extra checks for the given lang
     kind: Option<ExtraCheckKind>,
@@ -750,6 +845,58 @@ impl ExtraCheckArg {
         self.lang == lang && self.kind.map(|k| k == kind).unwrap_or(true)
     }
 
+    fn is_non_if_installed_or_matches(&self, root_path: &Path, build_dir: &Path) -> bool {
+        if !self.if_installed {
+            return true;
+        }
+
+        match self.lang {
+            ExtraCheckLang::Spellcheck => {
+                match ensure_version(build_dir, "typos", SPELLCHECK_VER) {
+                    Ok(_) => true,
+                    Err(Error::Version { installed, .. }) => {
+                        eprintln!(
+                            "warning: the tool `typos` is detected, but version {installed} doesn't match with the expected version {SPELLCHECK_VER}"
+                        );
+                        false
+                    }
+                    _ => false,
+                }
+            }
+            ExtraCheckLang::Shell => has_shellcheck().is_ok(),
+            ExtraCheckLang::Js => {
+                match self.kind {
+                    Some(ExtraCheckKind::Lint) => {
+                        // If Lint is enabled, check both eslint and es-check.
+                        rustdoc_js::has_tool(build_dir, "eslint")
+                            && rustdoc_js::has_tool(build_dir, "es-check")
+                    }
+                    Some(ExtraCheckKind::Typecheck) => {
+                        // If Typecheck is enabled, check tsc.
+                        rustdoc_js::has_tool(build_dir, "tsc")
+                    }
+                    None => {
+                        // No kind means it will check both Lint and Typecheck.
+                        rustdoc_js::has_tool(build_dir, "eslint")
+                            && rustdoc_js::has_tool(build_dir, "es-check")
+                            && rustdoc_js::has_tool(build_dir, "tsc")
+                    }
+                    Some(_) => unreachable!("js shouldn't have other type of ExtraCheckKind"),
+                }
+            }
+            ExtraCheckLang::Py | ExtraCheckLang::Cpp => {
+                let venv_path = build_dir.join("venv");
+                let mut reqs_path = root_path.to_owned();
+                reqs_path.extend(PIP_REQ_PATH);
+                let Ok(v) = has_py_tools(&venv_path, &reqs_path) else {
+                    return false;
+                };
+
+                v
+            }
+        }
+    }
+
     /// Returns `false` if this is an auto arg and the passed filename does not trigger the auto rule
     fn is_non_auto_or_matches(&self, filepath: &str) -> bool {
         if !self.auto {
@@ -792,22 +939,44 @@ impl FromStr for ExtraCheckArg {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut auto = false;
+        let mut if_installed = false;
         let mut parts = s.split(':');
-        let Some(mut first) = parts.next() else {
-            return Err(ExtraCheckParseError::Empty);
+        let mut first = match parts.next() {
+            Some("") | None => return Err(ExtraCheckParseError::Empty),
+            Some(part) => part,
         };
-        if first == "auto" {
-            let Some(part) = parts.next() else {
-                return Err(ExtraCheckParseError::AutoRequiresLang);
-            };
-            auto = true;
-            first = part;
+
+        // The loop allows users to specify `auto` and `if-installed` in any order.
+        // Both auto:if-installed:<check> and if-installed:auto:<check> are valid.
+        loop {
+            match (first, auto, if_installed) {
+                ("auto", false, _) => {
+                    let Some(part) = parts.next() else {
+                        return Err(ExtraCheckParseError::AutoRequiresLang);
+                    };
+                    auto = true;
+                    first = part;
+                }
+                ("if-installed", _, false) => {
+                    let Some(part) = parts.next() else {
+                        return Err(ExtraCheckParseError::IfInstalledRequiresLang);
+                    };
+                    if_installed = true;
+                    first = part;
+                }
+                _ => break,
+            }
         }
         let second = parts.next();
         if parts.next().is_some() {
             return Err(ExtraCheckParseError::TooManyParts);
         }
-        let arg = Self { auto, lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? };
+        let arg = Self {
+            auto,
+            if_installed,
+            lang: first.parse()?,
+            kind: second.map(|s| s.parse()).transpose()?,
+        };
         if !arg.has_supported_kind() {
             return Err(ExtraCheckParseError::UnsupportedKindForLang);
         }
@@ -816,7 +985,7 @@ impl FromStr for ExtraCheckArg {
     }
 }
 
-#[derive(PartialEq, Copy, Clone)]
+#[derive(PartialEq, Copy, Clone, Debug)]
 enum ExtraCheckLang {
     Py,
     Shell,
@@ -840,7 +1009,7 @@ impl FromStr for ExtraCheckLang {
     }
 }
 
-#[derive(PartialEq, Copy, Clone)]
+#[derive(PartialEq, Copy, Clone, Debug)]
 enum ExtraCheckKind {
     Lint,
     Fmt,
diff --git a/src/tools/tidy/src/extra_checks/rustdoc_js.rs b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
index 944d8a44112fa..6ad5a66650719 100644
--- a/src/tools/tidy/src/extra_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
@@ -21,6 +21,11 @@ fn spawn_cmd(cmd: &mut Command) -> Result<Child, io::Error> {
     })
 }
 
+pub(super) fn has_tool(outdir: &Path, name: &str) -> bool {
+    let bin_path = node_module_bin(outdir, name);
+    Command::new(bin_path).arg("--version").status().is_ok()
+}
+
 /// install all js dependencies from package.json.
 pub(super) fn npm_install(root_path: &Path, outdir: &Path, npm: &Path) -> Result<(), super::Error> {
     npm::install(root_path, outdir, npm)?;
diff --git a/src/tools/tidy/src/extra_checks/tests.rs b/src/tools/tidy/src/extra_checks/tests.rs
new file mode 100644
index 0000000000000..5d274069a80c2
--- /dev/null
+++ b/src/tools/tidy/src/extra_checks/tests.rs
@@ -0,0 +1,86 @@
+use std::str::FromStr;
+
+use crate::extra_checks::{ExtraCheckArg, ExtraCheckKind, ExtraCheckLang, ExtraCheckParseError};
+
+#[test]
+fn test_extra_check_arg_from_str_ok() {
+    let test_cases = [
+        (
+            "auto:if-installed:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "if-installed:auto:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "auto:spellcheck",
+            ExtraCheckArg {
+                auto: true,
+                if_installed: false,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "if-installed:spellcheck",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: true,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "spellcheck",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: false,
+                lang: ExtraCheckLang::Spellcheck,
+                kind: None,
+            },
+        ),
+        (
+            "js:lint",
+            ExtraCheckArg {
+                auto: false,
+                if_installed: false,
+                lang: ExtraCheckLang::Js,
+                kind: Some(ExtraCheckKind::Lint),
+            },
+        ),
+    ];
+
+    for (s, expected) in test_cases {
+        assert_eq!(ExtraCheckArg::from_str(s), Ok(expected));
+    }
+}
+
+#[test]
+fn test_extra_check_arg_from_str_err() {
+    let test_cases = [
+        ("some:spellcheck", ExtraCheckParseError::UnknownLang("some".to_string())),
+        ("spellcheck:some", ExtraCheckParseError::UnknownKind("some".to_string())),
+        ("spellcheck:lint", ExtraCheckParseError::UnsupportedKindForLang),
+        ("auto:spellcheck:some", ExtraCheckParseError::UnknownKind("some".to_string())),
+        ("auto:js:lint:some", ExtraCheckParseError::TooManyParts),
+        ("some", ExtraCheckParseError::UnknownLang("some".to_string())),
+        ("auto", ExtraCheckParseError::AutoRequiresLang),
+        ("if-installed", ExtraCheckParseError::IfInstalledRequiresLang),
+        ("", ExtraCheckParseError::Empty),
+    ];
+
+    for (s, expected) in test_cases {
+        assert_eq!(ExtraCheckArg::from_str(s), Err(expected));
+    }
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 756f9790e04ad..425f43e42b7f8 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -4,9 +4,7 @@
 //! to be used by tools.
 
 use std::ffi::OsStr;
-use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::{env, io};
 
 use build_helper::ci::CiEnv;
 use build_helper::git::{GitConfig, get_closest_upstream_commit};
@@ -158,77 +156,6 @@ pub fn files_modified(ci_info: &CiInfo, pred: impl Fn(&str) -> bool) -> bool {
     !v.is_empty()
 }
 
-/// If the given executable is installed with the given version, use that,
-/// otherwise install via cargo.
-pub fn ensure_version_or_cargo_install(
-    build_dir: &Path,
-    cargo: &Path,
-    pkg_name: &str,
-    bin_name: &str,
-    version: &str,
-) -> io::Result<PathBuf> {
-    let tool_root_dir = build_dir.join("misc-tools");
-    let tool_bin_dir = tool_root_dir.join("bin");
-    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
-
-    // ignore the process exit code here and instead just let the version number check fail.
-    // we also importantly don't return if the program wasn't installed,
-    // instead we want to continue to the fallback.
-    'ck: {
-        // FIXME: rewrite as if-let chain once this crate is 2024 edition.
-        let Ok(output) = Command::new(&bin_path).arg("--version").output() else {
-            break 'ck;
-        };
-        let Ok(s) = str::from_utf8(&output.stdout) else {
-            break 'ck;
-        };
-        let Some(v) = s.trim().split_whitespace().last() else {
-            break 'ck;
-        };
-        if v == version {
-            return Ok(bin_path);
-        }
-    }
-
-    eprintln!("building external tool {bin_name} from package {pkg_name}@{version}");
-    // use --force to ensure that if the required version is bumped, we update it.
-    // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
-    // modify PATH so that cargo doesn't print a warning telling the user to modify the path.
-    let mut cmd = Command::new(cargo);
-    cmd.args(["install", "--locked", "--force", "--quiet"])
-        .arg("--root")
-        .arg(&tool_root_dir)
-        .arg("--target-dir")
-        .arg(tool_root_dir.join("target"))
-        .arg(format!("{pkg_name}@{version}"))
-        .env(
-            "PATH",
-            env::join_paths(
-                env::split_paths(&env::var("PATH").unwrap())
-                    .chain(std::iter::once(tool_bin_dir.clone())),
-            )
-            .expect("build dir contains invalid char"),
-        );
-
-    // On CI, we set opt-level flag for quicker installation.
-    // Since lower opt-level decreases the tool's performance,
-    // we don't set this option on local.
-    if CiEnv::is_ci() {
-        cmd.env("RUSTFLAGS", "-Copt-level=0");
-    }
-
-    let cargo_exit_code = cmd.spawn()?.wait()?;
-    if !cargo_exit_code.success() {
-        return Err(io::Error::other("cargo install failed"));
-    }
-    assert!(
-        matches!(bin_path.try_exists(), Ok(true)),
-        "cargo install did not produce the expected binary"
-    );
-    eprintln!("finished building tool {bin_name}");
-    Ok(bin_path)
-}
-
 pub mod alphabetical;
 pub mod bins;
 pub mod debug_artifacts;
diff --git a/tests/rustdoc-html/intra-doc/deprecated.rs b/tests/rustdoc-html/intra-doc/deprecated.rs
new file mode 100644
index 0000000000000..6f8639593a2d4
--- /dev/null
+++ b/tests/rustdoc-html/intra-doc/deprecated.rs
@@ -0,0 +1,12 @@
+//@ has deprecated/struct.A.html '//a[@href="{{channel}}/core/ops/range/struct.Range.html#structfield.start"]' 'start'
+//@ has deprecated/struct.B1.html '//a[@href="{{channel}}/std/io/error/enum.ErrorKind.html#variant.NotFound"]' 'not_found'
+//@ has deprecated/struct.B2.html '//a[@href="{{channel}}/std/io/error/enum.ErrorKind.html#variant.NotFound"]' 'not_found'
+
+#[deprecated = "[start][std::ops::Range::start]"]
+pub struct A;
+
+#[deprecated(since = "0.0.0", note = "[not_found][std::io::ErrorKind::NotFound]")]
+pub struct B1;
+
+#[deprecated(note = "[not_found][std::io::ErrorKind::NotFound]", since = "0.0.0")]
+pub struct B2;
diff --git a/tests/rustdoc-ui/intra-doc/deprecated.rs b/tests/rustdoc-ui/intra-doc/deprecated.rs
new file mode 100644
index 0000000000000..37c27dcde598a
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/deprecated.rs
@@ -0,0 +1,10 @@
+#![deny(rustdoc::broken_intra_doc_links)]
+
+#[deprecated = "[broken cross-reference](TypeAlias::hoge)"] //~ ERROR
+pub struct A;
+
+#[deprecated(since = "0.0.0", note = "[broken cross-reference](TypeAlias::hoge)")] //~ ERROR
+pub struct B1;
+
+#[deprecated(note = "[broken cross-reference](TypeAlias::hoge)", since = "0.0.0")] //~ ERROR
+pub struct B2;
diff --git a/tests/rustdoc-ui/intra-doc/deprecated.stderr b/tests/rustdoc-ui/intra-doc/deprecated.stderr
new file mode 100644
index 0000000000000..9bd64544eef82
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/deprecated.stderr
@@ -0,0 +1,43 @@
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:3:1
+   |
+LL | #[deprecated = "[broken cross-reference](TypeAlias::hoge)"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+note: the lint level is defined here
+  --> $DIR/deprecated.rs:1:9
+   |
+LL | #![deny(rustdoc::broken_intra_doc_links)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:6:1
+   |
+LL | #[deprecated(since = "0.0.0", note = "[broken cross-reference](TypeAlias::hoge)")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+
+error: unresolved link to `TypeAlias::hoge`
+  --> $DIR/deprecated.rs:9:1
+   |
+LL | #[deprecated(note = "[broken cross-reference](TypeAlias::hoge)", since = "0.0.0")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the link appears in this line:
+           
+           [broken cross-reference](TypeAlias::hoge)
+                                    ^^^^^^^^^^^^^^^
+   = note: no item named `TypeAlias` in scope
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
index eb8f04b8b24bb..8131a5b723436 100644
--- a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
+++ b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.rs
@@ -1,8 +1,4 @@
-// We allow for literals to implicitly be anon consts still regardless
-// of whether a const block is placed around them or not
-//
-// However, we don't allow so for const arguments in field init positions.
-// This is just harder to implement so we did not do so.
+//@ check-pass
 
 #![feature(min_generic_const_args, adt_const_params)]
 #![expect(incomplete_features)]
@@ -27,7 +23,7 @@ fn struct_expr() {
     fn takes_n<const N: ADT>() {}
 
     takes_n::<{ ADT { field: 1 } }>();
-    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+
     takes_n::<{ ADT { field: const { 1 } } }>();
 }
 
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr b/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr
deleted file mode 100644
index 02647fd808cce..0000000000000
--- a/tests/ui/const-generics/mgca/explicit_anon_consts_literals_hack.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts_literals_hack.rs:29:30
-   |
-LL |     takes_n::<{ ADT { field: 1 } }>();
-   |                              ^
-
-error: aborting due to 1 previous error
-