diff --git a/.github/ISSUE_TEMPLATE/tracking_issue.md b/.github/ISSUE_TEMPLATE/tracking_issue.md
index aedc15a54c274..6def803b269e9 100644
--- a/.github/ISSUE_TEMPLATE/tracking_issue.md
+++ b/.github/ISSUE_TEMPLATE/tracking_issue.md
@@ -50,7 +50,7 @@ for larger features an implementation could be broken up into multiple PRs.
 [stabilization-guide]: https://rustc-dev-guide.rust-lang.org/stabilization_guide.html#stabilization-pr
 [doc-guide]: https://rustc-dev-guide.rust-lang.org/stabilization_guide.html#documentation-prs
 [nightly-style-procedure]: https://github.com/rust-lang/style-team/blob/main/nightly-style-procedure.md 
-[Style Guide]: https://github.com/rust-lang/rust/tree/master/src/doc/style-guide
+[Style Guide]: https://github.com/rust-lang/rust/tree/HEAD/src/doc/style-guide
 
 ### Unresolved Questions
 <!--
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d440b296d2753..4e683758d6df2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -323,7 +323,7 @@ jobs:
       # If a some dependent job has failed, this exits with 1.
       - name: calculate the correct exit status
         run: jq --exit-status 'all(.result == "success" or .result == "skipped")' <<< '${{ toJson(needs) }}'
-      # Publish the toolstate if an auto build succeeds (just before push to master)
+      # Publish the toolstate if an auto build succeeds (just before push to the default branch)
       - name: publish toolstate
         run: src/ci/publish_toolstate.sh
         shell: bash
diff --git a/.github/workflows/post-merge.yml b/.github/workflows/post-merge.yml
index 12ff4be4f1e8c..b4848a8cf099b 100644
--- a/.github/workflows/post-merge.yml
+++ b/.github/workflows/post-merge.yml
@@ -1,4 +1,4 @@
-# Workflow that runs after a merge to master, analyses changes in test executions
+# Workflow that runs after a merge to the default branch, analyses changes in test executions
 # and posts the result to the merged PR.
 
 name: Post merge analysis
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 5ac3a87c158e6..02b50fa8a6971 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -77,6 +77,9 @@ fn prepare_lto(
     // should have default visibility.
     symbols_below_threshold.push(c"__llvm_profile_counter_bias".to_owned());
 
+    // LTO seems to discard this otherwise under certain circumstances.
+    symbols_below_threshold.push(c"rust_eh_personality".to_owned());
+
     // If we're performing LTO for the entire crate graph, then for each of our
     // upstream dependencies, find the corresponding rlib and load the bitcode
     // from the archive.
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index c082a82306848..49d38e05c8b06 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -16,7 +16,6 @@ use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_hir::def_id::DefId;
-use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasTypingEnv, LayoutError, LayoutOfHelpers,
@@ -1458,10 +1457,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
         match &fn_abi.ret.mode {
             PassMode::Ignore | PassMode::Indirect { .. } => self.ret_void(),
-            PassMode::Direct(_) | PassMode::Pair { .. } => self.ret(call),
-            mode @ PassMode::Cast { .. } => {
-                bug!("Encountered `PassMode::{mode:?}` during codegen")
-            }
+            PassMode::Direct(_) | PassMode::Pair { .. } | PassMode::Cast { .. } => self.ret(call),
         }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 3b920168e06dc..0fcad0376b11c 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -213,7 +213,7 @@ impl<'a> IntoIterator for LLVMFeature<'a> {
 ///
 /// Check the current rustc fork of LLVM in the repo at
 /// <https://github.com/rust-lang/llvm-project/>. The commit in use can be found via the
-/// `llvm-project` submodule in <https://github.com/rust-lang/rust/tree/master/src> Though note that
+/// `llvm-project` submodule in <https://github.com/rust-lang/rust/tree/HEAD/src> Though note that
 /// Rust can also be build with an external precompiled version of LLVM which might lead to failures
 /// if the oldest tested / supported LLVM version doesn't yet support the relevant intrinsics.
 pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFeature<'a>> {
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
index 5bc18e2d7f8bb..d9ba5017a422d 100644
--- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
+++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -51,15 +51,7 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
         return Default::default();
     }
 
-    // Check to see if this crate is a "special runtime crate". These
-    // crates, implementation details of the standard library, typically
-    // have a bunch of `pub extern` and `#[no_mangle]` functions as the
-    // ABI between them. We don't want their symbols to have a `C`
-    // export level, however, as they're just implementation details.
-    // Down below we'll hardwire all of the symbols to the `Rust` export
-    // level instead.
-    let special_runtime_crate =
-        tcx.is_panic_runtime(LOCAL_CRATE) || tcx.is_compiler_builtins(LOCAL_CRATE);
+    let is_compiler_builtins = tcx.is_compiler_builtins(LOCAL_CRATE);
 
     let mut reachable_non_generics: DefIdMap<_> = tcx
         .reachable_set(())
@@ -104,11 +96,12 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
             if tcx.cross_crate_inlinable(def_id) { None } else { Some(def_id) }
         })
         .map(|def_id| {
-            // We won't link right if this symbol is stripped during LTO.
-            let name = tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())).name;
-            let used = name == "rust_eh_personality";
-
-            let export_level = if special_runtime_crate {
+            let export_level = if is_compiler_builtins {
+                // We don't want to export compiler-builtins symbols from any
+                // dylibs, even rust dylibs. Unlike all other crates it gets
+                // duplicated in every linker invocation and it may otherwise
+                // unintentionally override definitions of these symbols by
+                // libgcc or compiler-rt for C code.
                 SymbolExportLevel::Rust
             } else {
                 symbol_export_level(tcx, def_id.to_def_id())
@@ -131,8 +124,7 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
                     SymbolExportKind::Text
                 },
                 used: codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
-                    || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
-                    || used,
+                    || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER),
                 rustc_std_internal_symbol: codegen_attrs
                     .flags
                     .contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL),
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index e2241a77d186c..0d1e27a34dc5b 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1063,7 +1063,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let return_dest = self.make_return_dest(bx, destination, &fn_abi.ret, &mut llargs);
                 target.map(|target| (return_dest, target))
             }
-            CallKind::Tail => None,
+            CallKind::Tail => {
+                if fn_abi.ret.is_indirect() {
+                    match self.make_return_dest(bx, destination, &fn_abi.ret, &mut llargs) {
+                        ReturnDest::Nothing => {}
+                        _ => bug!(
+                            "tail calls to functions with indirect returns cannot store into a destination"
+                        ),
+                    }
+                }
+                None
+            }
         };
 
         // Split the rust-call tupled arguments off.
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index 79e32dcf105c9..d81b31b704b3d 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -1,8 +1,8 @@
 //! Concrete error types for all operations which may be invalid in a certain const context.
 
 use hir::{ConstContext, LangItem};
-use rustc_errors::Diag;
 use rustc_errors::codes::*;
+use rustc_errors::{Applicability, Diag, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -11,8 +11,8 @@ use rustc_middle::mir::CallSource;
 use rustc_middle::span_bug;
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
 use rustc_middle::ty::{
-    self, Closure, FnDef, FnPtr, GenericArgKind, GenericArgsRef, Param, TraitRef, Ty,
-    suggest_constraining_type_param,
+    self, AssocContainer, Closure, FnDef, FnPtr, GenericArgKind, GenericArgsRef, Param, TraitRef,
+    Ty, suggest_constraining_type_param,
 };
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
@@ -352,18 +352,71 @@ fn build_error_for_const_call<'tcx>(
                 non_or_conditionally,
             })
         }
-        _ => ccx.dcx().create_err(errors::NonConstFnCall {
-            span,
-            def_descr: ccx.tcx.def_descr(callee),
-            def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
-            kind: ccx.const_kind(),
-            non_or_conditionally,
-        }),
+        _ => {
+            let def_descr = ccx.tcx.def_descr(callee);
+            let mut err = ccx.dcx().create_err(errors::NonConstFnCall {
+                span,
+                def_descr,
+                def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
+                kind: ccx.const_kind(),
+                non_or_conditionally,
+            });
+            if let Some(item) = ccx.tcx.opt_associated_item(callee) {
+                if let AssocContainer::Trait = item.container
+                    && let parent = item.container_id(ccx.tcx)
+                    && !ccx.tcx.is_const_trait(parent)
+                {
+                    let assoc_span = ccx.tcx.def_span(callee);
+                    let assoc_name = ccx.tcx.item_name(callee);
+                    let mut span: MultiSpan = ccx.tcx.def_span(parent).into();
+                    span.push_span_label(assoc_span, format!("this {def_descr} is not const"));
+                    let trait_descr = ccx.tcx.def_descr(parent);
+                    let trait_span = ccx.tcx.def_span(parent);
+                    let trait_name = ccx.tcx.item_name(parent);
+                    span.push_span_label(trait_span, format!("this {trait_descr} is not const"));
+                    err.span_note(
+                        span,
+                        format!(
+                            "{def_descr} `{assoc_name}` is not const because {trait_descr} \
+                            `{trait_name}` is not const",
+                        ),
+                    );
+                    if parent.is_local() && ccx.tcx.sess.is_nightly_build() {
+                        if !ccx.tcx.features().const_trait_impl() {
+                            err.help(
+                                "add `#![feature(const_trait_impl)]` to the crate attributes to \
+                                 enable `#[const_trait]`",
+                            );
+                        }
+                        let indentation = ccx
+                            .tcx
+                            .sess
+                            .source_map()
+                            .indentation_before(trait_span)
+                            .unwrap_or_default();
+                        err.span_suggestion_verbose(
+                            trait_span.shrink_to_lo(),
+                            format!("consider making trait `{trait_name}` const"),
+                            format!("#[const_trait]\n{indentation}"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    } else if !ccx.tcx.sess.is_nightly_build() {
+                        err.help("const traits are not yet supported on stable Rust");
+                    }
+                }
+            } else if ccx.tcx.constness(callee) != hir::Constness::Const {
+                let name = ccx.tcx.item_name(callee);
+                err.span_note(
+                    ccx.tcx.def_span(callee),
+                    format!("{def_descr} `{name}` is not const"),
+                );
+            }
+            err
+        }
     };
 
     err.note(format!(
-        "calls in {}s are limited to constant functions, \
-             tuple structs and tuple variants",
+        "calls in {}s are limited to constant functions, tuple structs and tuple variants",
         ccx.const_kind(),
     ));
 
diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
index 60303d5ee81e4..325be43a0065c 100644
--- a/compiler/rustc_hir_typeck/messages.ftl
+++ b/compiler/rustc_hir_typeck/messages.ftl
@@ -266,6 +266,8 @@ hir_typeck_self_ctor_from_outer_item = can't reference `Self` constructor from o
     .label = the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
     .suggestion = replace `Self` with the actual type
 
+hir_typeck_self_ctor_from_outer_item_inner_item = `Self` used in this inner item
+
 hir_typeck_slicing_suggestion = consider slicing here
 
 hir_typeck_struct_expr_non_exhaustive =
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 615a8c95056d1..41fcfbdbfd4bc 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -978,6 +978,15 @@ pub(crate) struct SelfCtorFromOuterItem {
     pub impl_span: Span,
     #[subdiagnostic]
     pub sugg: Option<ReplaceWithName>,
+    #[subdiagnostic]
+    pub item: Option<InnerItem>,
+}
+
+#[derive(Subdiagnostic)]
+#[label(hir_typeck_self_ctor_from_outer_item_inner_item)]
+pub(crate) struct InnerItem {
+    #[primary_span]
+    pub span: Span,
 }
 
 #[derive(LintDiagnostic)]
@@ -987,6 +996,8 @@ pub(crate) struct SelfCtorFromOuterItemLint {
     pub impl_span: Span,
     #[subdiagnostic]
     pub sugg: Option<ReplaceWithName>,
+    #[subdiagnostic]
+    pub item: Option<InnerItem>,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index f4e65b42cd423..38586c844445b 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1094,11 +1094,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     span: path_span,
                     name: self.tcx.item_name(def.did()).to_ident_string(),
                 });
+                let item = match self
+                    .tcx
+                    .hir_node_by_def_id(self.tcx.hir_get_parent_item(hir_id).def_id)
+                {
+                    hir::Node::Item(item) => Some(errors::InnerItem {
+                        span: item.kind.ident().map(|i| i.span).unwrap_or(item.span),
+                    }),
+                    _ => None,
+                };
                 if ty.raw.has_param() {
                     let guar = self.dcx().emit_err(errors::SelfCtorFromOuterItem {
                         span: path_span,
                         impl_span: tcx.def_span(impl_def_id),
                         sugg,
+                        item,
                     });
                     return (Ty::new_error(self.tcx, guar), res);
                 } else {
@@ -1109,6 +1119,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         errors::SelfCtorFromOuterItemLint {
                             impl_span: tcx.def_span(impl_def_id),
                             sugg,
+                            item,
                         },
                     );
                 }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
index 837328e379ca3..854202c312705 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
@@ -94,20 +94,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let find_param_matching = |matches: &dyn Fn(ParamTerm) -> bool| {
             predicate_args.iter().find_map(|arg| {
-                arg.walk().find_map(|arg| {
-                    if let ty::GenericArgKind::Type(ty) = arg.kind()
-                        && let ty::Param(param_ty) = *ty.kind()
-                        && matches(ParamTerm::Ty(param_ty))
-                    {
-                        Some(arg)
-                    } else if let ty::GenericArgKind::Const(ct) = arg.kind()
-                        && let ty::ConstKind::Param(param_ct) = ct.kind()
-                        && matches(ParamTerm::Const(param_ct))
+                arg.walk().find(|arg| match arg.kind() {
+                    ty::GenericArgKind::Type(ty) if let ty::Param(param_ty) = ty.kind() => {
+                        matches(ParamTerm::Ty(*param_ty))
+                    }
+                    ty::GenericArgKind::Const(ct)
+                        if let ty::ConstKind::Param(param_ct) = ct.kind() =>
                     {
-                        Some(arg)
-                    } else {
-                        None
+                        matches(ParamTerm::Const(param_ct))
                     }
+                    _ => false,
                 })
             })
         };
@@ -162,7 +158,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .into_iter()
                 .flatten()
                 {
-                    if self.point_at_path_if_possible(error, def_id, param, &qpath) {
+                    if self.point_at_path_if_possible(error, def_id, param, qpath) {
                         return true;
                     }
                 }
@@ -194,7 +190,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 args,
             ) => {
                 if let Some(param) = predicate_self_type_to_point_at
-                    && self.point_at_path_if_possible(error, callee_def_id, param, &qpath)
+                    && self.point_at_path_if_possible(error, callee_def_id, param, qpath)
                 {
                     return true;
                 }
@@ -225,7 +221,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .into_iter()
                     .flatten()
                 {
-                    if self.point_at_path_if_possible(error, callee_def_id, param, &qpath) {
+                    if self.point_at_path_if_possible(error, callee_def_id, param, qpath) {
                         return true;
                     }
                 }
@@ -543,10 +539,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// - `blame_specific_*` means that the function will recursively traverse the expression,
-    /// looking for the most-specific-possible span to blame.
+    ///   looking for the most-specific-possible span to blame.
     ///
     /// - `point_at_*` means that the function will only go "one level", pointing at the specific
-    /// expression mentioned.
+    ///   expression mentioned.
     ///
     /// `blame_specific_arg_if_possible` will find the most-specific expression anywhere inside
     /// the provided function call expression, and mark it as responsible for the fulfillment
@@ -609,6 +605,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
      * - want `Vec<i32>: Copy`
      * - because `Option<Vec<i32>>: Copy` needs `Vec<i32>: Copy` because `impl <T: Copy> Copy for Option<T>`
      * - because `(Option<Vec<i32>, bool)` needs `Option<Vec<i32>>: Copy` because `impl <A: Copy, B: Copy> Copy for (A, B)`
+     *
      * then if you pass in `(Some(vec![1, 2, 3]), false)`, this helper `point_at_specific_expr_if_possible`
      * will find the expression `vec![1, 2, 3]` as the "most blameable" reason for this missing constraint.
      *
@@ -749,6 +746,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// - expr: `(Some(vec![1, 2, 3]), false)`
     /// - param: `T`
     /// - in_ty: `(Option<Vec<T>, bool)`
+    ///
     /// we would drill until we arrive at `vec![1, 2, 3]`.
     ///
     /// If successful, we return `Ok(refined_expr)`. If unsuccessful, we return `Err(partially_refined_expr`),
@@ -1016,7 +1014,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .variant_with_id(variant_def_id)
                     .fields
                     .iter()
-                    .map(|field| field.ty(self.tcx, *in_ty_adt_generic_args))
+                    .map(|field| field.ty(self.tcx, in_ty_adt_generic_args))
                     .enumerate()
                     .filter(|(_index, field_type)| find_param_in_ty((*field_type).into(), param)),
             ) else {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
index f6298adf2ebb7..16f0a7dbc6f33 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
@@ -174,7 +174,7 @@ impl<'tcx> ArgMatrix<'tcx> {
                 return Some(Issue::Missing(next_unmatched_idx));
             }
             // If we eliminate the last column, any left-over inputs are extra
-            if mat[i].len() == 0 {
+            if mat[i].is_empty() {
                 return Some(Issue::Extra(next_unmatched_idx));
             }
 
@@ -187,28 +187,18 @@ impl<'tcx> ArgMatrix<'tcx> {
                 continue;
             }
 
-            let mut useless = true;
-            let mut unsatisfiable = true;
-            if is_arg {
-                for j in 0..ii.len() {
-                    // If we find at least one input this argument could satisfy
-                    // this argument isn't unsatisfiable
-                    if matches!(mat[j][i], Compatibility::Compatible) {
-                        unsatisfiable = false;
-                        break;
-                    }
-                }
-            }
-            if is_input {
-                for j in 0..ai.len() {
-                    // If we find at least one argument that could satisfy this input
-                    // this input isn't useless
-                    if matches!(mat[i][j], Compatibility::Compatible) {
-                        useless = false;
-                        break;
-                    }
-                }
-            }
+            // If this argument can satisfy some input, then this argument is satisfiable
+            let unsatisfiable = if is_arg {
+                !mat.iter().take(ii.len()).any(|c| matches!(c[i], Compatibility::Compatible))
+            } else {
+                true
+            };
+            // If this input can be satisfied by some argument, then this input is useful
+            let useless = if is_input {
+                !mat[i].iter().take(ai.len()).any(|c| matches!(c, Compatibility::Compatible))
+            } else {
+                true
+            };
 
             match (is_input, is_arg, useless, unsatisfiable) {
                 // If an argument is unsatisfied, and the input in its position is useless
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 0cbdd86768a67..127f2c676391d 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -777,10 +777,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
                 _ => bug!("unexpected type: {:?}", ty.normalized),
             },
-            Res::Def(
-                DefKind::Struct | DefKind::Union | DefKind::TyAlias { .. } | DefKind::AssocTy,
-                _,
-            )
+            Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
             | Res::SelfTyParam { .. }
             | Res::SelfTyAlias { .. } => match ty.normalized.ty_adt_def() {
                 Some(adt) if !adt.is_enum() => {
@@ -868,7 +865,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let decl_ty = self.local_ty(decl.span, decl.hir_id);
 
         // Type check the initializer.
-        if let Some(ref init) = decl.init {
+        if let Some(init) = decl.init {
             let init_ty = self.check_decl_initializer(decl.hir_id, decl.pat, init);
             self.overwrite_local_ty_if_err(decl.hir_id, decl.pat, init_ty);
         }
@@ -932,7 +929,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             // Ignore for now.
             hir::StmtKind::Item(_) => {}
-            hir::StmtKind::Expr(ref expr) => {
+            hir::StmtKind::Expr(expr) => {
                 // Check with expected type of `()`.
                 self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
                     if self.is_next_stmt_expr_continuation(stmt.hir_id)
@@ -1766,10 +1763,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let params =
                     params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
                 debug_assert_eq!(params.len(), fn_inputs.len());
-                Some((
-                    fn_inputs.zip(params.iter().map(|param| FnParam::Param(param))).collect(),
-                    generics,
-                ))
+                Some((fn_inputs.zip(params.iter().map(FnParam::Param)).collect(), generics))
             }
             (None, Some(params)) => {
                 let params =
@@ -2632,7 +2626,7 @@ impl<'a, 'b, 'tcx> FnCallDiagCtxt<'a, 'b, 'tcx> {
         suggestions: Vec<(Span, String)>,
         suggestion_text: SuggestionText,
     ) -> Option<String> {
-        let suggestion_text = match suggestion_text {
+        match suggestion_text {
             SuggestionText::None => None,
             SuggestionText::Provide(plural) => {
                 Some(format!("provide the argument{}", if plural { "s" } else { "" }))
@@ -2648,8 +2642,7 @@ impl<'a, 'b, 'tcx> FnCallDiagCtxt<'a, 'b, 'tcx> {
             SuggestionText::Swap => Some("swap these arguments".to_string()),
             SuggestionText::Reorder => Some("reorder these arguments".to_string()),
             SuggestionText::DidYouMean => Some("did you mean".to_string()),
-        };
-        suggestion_text
+        }
     }
 
     fn arguments_formatting(&self, suggestion_span: Span) -> ArgumentsFormatting {
@@ -2947,7 +2940,7 @@ impl<'a, 'b, 'tcx> ArgsCtxt<'a, 'b, 'tcx> {
                     .fn_ctxt
                     .typeck_results
                     .borrow()
-                    .expr_ty_adjusted_opt(*expr)
+                    .expr_ty_adjusted_opt(expr)
                     .unwrap_or_else(|| Ty::new_misc_error(self.call_ctxt.fn_ctxt.tcx));
                 (
                     self.call_ctxt.fn_ctxt.resolve_vars_if_possible(ty),
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 28bd3e7e8d5bb..1d16c3af7fb75 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1132,7 +1132,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             })
             .collect::<Vec<String>>();
 
-        if all_matching_bounds_strs.len() == 0 {
+        if all_matching_bounds_strs.is_empty() {
             return;
         }
 
@@ -1336,7 +1336,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     expected_ty = *inner_expected_ty;
                 }
                 (hir::ExprKind::Block(blk, _), _, _) => {
-                    self.suggest_block_to_brackets(diag, *blk, expr_ty, expected_ty);
+                    self.suggest_block_to_brackets(diag, blk, expr_ty, expected_ty);
                     break true;
                 }
                 _ => break false,
@@ -1463,7 +1463,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             let span = expr
                 .span
-                .find_ancestor_not_from_extern_macro(&self.tcx.sess.source_map())
+                .find_ancestor_not_from_extern_macro(self.tcx.sess.source_map())
                 .unwrap_or(expr.span);
 
             let mut sugg = if self.precedence(expr) >= ExprPrecedence::Unambiguous {
@@ -2144,7 +2144,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let span = expr
             .span
-            .find_ancestor_not_from_extern_macro(&self.tcx.sess.source_map())
+            .find_ancestor_not_from_extern_macro(self.tcx.sess.source_map())
             .unwrap_or(expr.span);
         err.span_suggestion_verbose(span.shrink_to_hi(), msg, sugg, Applicability::HasPlaceholders);
         true
@@ -2257,7 +2257,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
             let src_map = tcx.sess.source_map();
             let suggestion = if src_map.is_multiline(expr.span) {
-                let indentation = src_map.indentation_before(span).unwrap_or_else(String::new);
+                let indentation = src_map.indentation_before(span).unwrap_or_default();
                 format!("\n{indentation}/* {suggestion} */")
             } else {
                 // If the entire expr is on a single line
@@ -2289,7 +2289,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Check if `expr` is contained in array of two elements
         if let hir::Node::Expr(array_expr) = self.tcx.parent_hir_node(expr.hir_id)
             && let hir::ExprKind::Array(elements) = array_expr.kind
-            && let [first, second] = &elements[..]
+            && let [first, second] = elements
             && second.hir_id == expr.hir_id
         {
             // Span between the two elements of the array
diff --git a/compiler/rustc_hir_typeck/src/gather_locals.rs b/compiler/rustc_hir_typeck/src/gather_locals.rs
index f1d6476a0f363..85c8400f227bd 100644
--- a/compiler/rustc_hir_typeck/src/gather_locals.rs
+++ b/compiler/rustc_hir_typeck/src/gather_locals.rs
@@ -135,7 +135,7 @@ impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
     /// again during type checking by querying [`FnCtxt::local_ty`] for the same hir_id.
     fn declare(&mut self, decl: Declaration<'tcx>) {
         let local_ty = match decl.ty {
-            Some(ref ty) => {
+            Some(ty) => {
                 let o_ty = self.fcx.lower_ty(ty);
 
                 let c_ty = self.fcx.infcx.canonicalize_user_type_annotation(
diff --git a/compiler/rustc_hir_typeck/src/loops.rs b/compiler/rustc_hir_typeck/src/loops.rs
index acfa5c473aacc..799e82ec13b80 100644
--- a/compiler/rustc_hir_typeck/src/loops.rs
+++ b/compiler/rustc_hir_typeck/src/loops.rs
@@ -147,7 +147,7 @@ impl<'hir> Visitor<'hir> for CheckLoopVisitor<'hir> {
                     }
                 }
             }
-            hir::ExprKind::Loop(ref b, _, source, _) => {
+            hir::ExprKind::Loop(b, _, source, _) => {
                 let cx = match self.is_loop_match(e, b) {
                     Some(labeled_block) => LoopMatch { labeled_block },
                     None => Loop(source),
@@ -155,9 +155,7 @@ impl<'hir> Visitor<'hir> for CheckLoopVisitor<'hir> {
 
                 self.with_context(cx, |v| v.visit_block(b));
             }
-            hir::ExprKind::Closure(&hir::Closure {
-                ref fn_decl, body, fn_decl_span, kind, ..
-            }) => {
+            hir::ExprKind::Closure(&hir::Closure { fn_decl, body, fn_decl_span, kind, .. }) => {
                 let cx = match kind {
                     hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(kind, source)) => {
                         Coroutine { coroutine_span: fn_decl_span, kind, source }
@@ -167,16 +165,16 @@ impl<'hir> Visitor<'hir> for CheckLoopVisitor<'hir> {
                 self.visit_fn_decl(fn_decl);
                 self.with_context(cx, |v| v.visit_nested_body(body));
             }
-            hir::ExprKind::Block(ref b, Some(_label)) => {
+            hir::ExprKind::Block(b, Some(_label)) => {
                 self.with_context(LabeledBlock, |v| v.visit_block(b));
             }
-            hir::ExprKind::Block(ref b, None)
+            hir::ExprKind::Block(b, None)
                 if matches!(self.cx_stack.last(), Some(&Fn) | Some(&ConstBlock)) =>
             {
                 self.with_context(Normal, |v| v.visit_block(b));
             }
             hir::ExprKind::Block(
-                ref b @ hir::Block { rules: hir::BlockCheckMode::DefaultBlock, .. },
+                b @ hir::Block { rules: hir::BlockCheckMode::DefaultBlock, .. },
                 None,
             ) if matches!(
                 self.cx_stack.last(),
@@ -431,10 +429,7 @@ impl<'hir> CheckLoopVisitor<'hir> {
 
         // Accept either `state = expr` or `state = expr;`.
         let loop_body_expr = match body.stmts {
-            [] => match body.expr {
-                Some(expr) => expr,
-                None => return None,
-            },
+            [] => body.expr?,
             [single] if body.expr.is_none() => match single.kind {
                 hir::StmtKind::Expr(expr) | hir::StmtKind::Semi(expr) => expr,
                 _ => return None,
diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 96e85fdb10a6e..a9bdf597e128f 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -1409,7 +1409,7 @@ impl<R: Idx, C: Idx> BitMatrix<R, C> {
         BitMatrix {
             num_rows,
             num_columns,
-            words: iter::repeat(&row.words).take(num_rows).flatten().cloned().collect(),
+            words: iter::repeat_n(&row.words, num_rows).flatten().cloned().collect(),
             marker: PhantomData,
         }
     }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index c32a9586f76fd..e6bbdc87d9958 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -42,7 +42,7 @@
 //!   Only valid for queries returning `Result<_, ErrorGuaranteed>`.
 //!
 //! For the up-to-date list, see the `QueryModifiers` struct in
-//! [`rustc_macros/src/query.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_macros/src/query.rs)
+//! [`rustc_macros/src/query.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_macros/src/query.rs)
 //! and for more details in incremental compilation, see the
 //! [Query modifiers in incremental compilation](https://rustc-dev-guide.rust-lang.org/queries/incremental-compilation-in-detail.html#query-modifiers) section of the rustc-dev-guide.
 //!
diff --git a/compiler/rustc_mir_transform/src/impossible_predicates.rs b/compiler/rustc_mir_transform/src/impossible_predicates.rs
index 883ee32bdec91..71e4d5581ddc2 100644
--- a/compiler/rustc_mir_transform/src/impossible_predicates.rs
+++ b/compiler/rustc_mir_transform/src/impossible_predicates.rs
@@ -20,11 +20,11 @@
 //! parameters, so this filtering serves two purposes:
 //!
 //! 1. We skip evaluating any predicates that we would
-//! never be able prove are unsatisfiable (e.g. `<T as Foo>`
+//!    never be able prove are unsatisfiable (e.g. `<T as Foo>`
 //! 2. We avoid trying to normalize predicates involving generic
-//! parameters (e.g. `<T as Foo>::MyItem`). This can confuse
-//! the normalization code (leading to cycle errors), since
-//! it's usually never invoked in this way.
+//!    parameters (e.g. `<T as Foo>::MyItem`). This can confuse
+//!    the normalization code (leading to cycle errors), since
+//!    it's usually never invoked in this way.
 
 use rustc_middle::mir::{Body, START_BLOCK, TerminatorKind};
 use rustc_middle::ty::{TyCtxt, TypeFlags, TypeVisitableExt};
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index dc6088849bf5e..7e1dd76f903d4 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -635,7 +635,7 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
 
     // Normally, this shouldn't be required, but trait normalization failure can create a
     // validation ICE.
-    if !validate_types(tcx, inliner.typing_env(), &callee_body, &caller_body).is_empty() {
+    if !validate_types(tcx, inliner.typing_env(), &callee_body, caller_body).is_empty() {
         debug!("failed to validate callee body");
         return Err("implementation limitation -- callee body failed validation");
     }
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index 5bf90d2637df5..d462ff589f0da 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -180,6 +180,11 @@ resolve_generic_params_from_outer_item_const = a `const` is a separate item from
 
 resolve_generic_params_from_outer_item_const_param = const parameter from outer item
 
+resolve_generic_params_from_outer_item_inner_item = {$is_self ->
+        [true] `Self`
+        *[false] generic parameter
+    } used in this inner {$descr}
+
 resolve_generic_params_from_outer_item_self_ty_alias = `Self` type implicitly declared here, by this `impl`
 
 resolve_generic_params_from_outer_item_self_ty_param = can't use `Self` here
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 236ab1f09d35f..3020ecb6e7113 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -40,7 +40,7 @@ use crate::errors::{
     MaybeMissingMacroRulesName,
 };
 use crate::imports::{Import, ImportKind};
-use crate::late::{PatternSource, Rib};
+use crate::late::{DiagMetadata, PatternSource, Rib};
 use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, BindingKey, Finalize,
     ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope, Module,
@@ -553,11 +553,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         resolution_error: ResolutionError<'ra>,
     ) -> Diag<'_> {
         match resolution_error {
-            ResolutionError::GenericParamsFromOuterItem(
+            ResolutionError::GenericParamsFromOuterItem {
                 outer_res,
                 has_generic_params,
                 def_kind,
-            ) => {
+                inner_item,
+            } => {
                 use errs::GenericParamsFromOuterItemLabel as Label;
                 let static_or_const = match def_kind {
                     DefKind::Static { .. } => {
@@ -575,6 +576,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     sugg: None,
                     static_or_const,
                     is_self,
+                    item: inner_item.as_ref().map(|(span, kind)| {
+                        errs::GenericParamsFromOuterItemInnerItem {
+                            span: *span,
+                            descr: kind.descr().to_string(),
+                        }
+                    }),
                 };
 
                 let sm = self.tcx.sess.source_map();
@@ -608,7 +615,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                 };
 
-                if let HasGenericParams::Yes(span) = has_generic_params {
+                if let HasGenericParams::Yes(span) = has_generic_params
+                    && !matches!(inner_item, Some((_, ItemKind::Delegation(..))))
+                {
                     let name = self.tcx.item_name(def_id);
                     let (span, snippet) = if span.is_empty() {
                         let snippet = format!("<{name}>");
@@ -2401,6 +2410,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         module: Option<ModuleOrUniformRoot<'ra>>,
         failed_segment_idx: usize,
         ident: Ident,
+        diag_metadata: Option<&DiagMetadata<'_>>,
     ) -> (String, Option<Suggestion>) {
         let is_last = failed_segment_idx == path.len() - 1;
         let ns = if is_last { opt_ns.unwrap_or(TypeNS) } else { TypeNS };
@@ -2506,6 +2516,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         None,
                         &ribs[ns_to_try],
                         ignore_binding,
+                        diag_metadata,
                     ) {
                         // we found a locally-imported or available item/module
                         Some(LexicalScopeBinding::Item(binding)) => Some(binding),
@@ -2556,6 +2567,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     None,
                     &ribs[ValueNS],
                     ignore_binding,
+                    diag_metadata,
                 )
             } else {
                 None
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index f0ea97ba8a0c0..5c5938a3260ed 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -24,6 +24,16 @@ pub(crate) struct GenericParamsFromOuterItem {
     #[subdiagnostic]
     pub(crate) static_or_const: Option<GenericParamsFromOuterItemStaticOrConst>,
     pub(crate) is_self: bool,
+    #[subdiagnostic]
+    pub(crate) item: Option<GenericParamsFromOuterItemInnerItem>,
+}
+
+#[derive(Subdiagnostic)]
+#[label(resolve_generic_params_from_outer_item_inner_item)]
+pub(crate) struct GenericParamsFromOuterItemInnerItem {
+    #[primary_span]
+    pub(crate) span: Span,
+    pub(crate) descr: String,
 }
 
 #[derive(Subdiagnostic)]
@@ -47,7 +57,12 @@ pub(crate) enum GenericParamsFromOuterItemLabel {
 }
 
 #[derive(Subdiagnostic)]
-#[suggestion(resolve_suggestion, code = "{snippet}", applicability = "maybe-incorrect")]
+#[suggestion(
+    resolve_suggestion,
+    code = "{snippet}",
+    applicability = "maybe-incorrect",
+    style = "verbose"
+)]
 pub(crate) struct GenericParamsFromOuterItemSugg {
     #[primary_span]
     pub(crate) span: Span,
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 2a195c8068dac..278c0fe35b7d8 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -12,7 +12,9 @@ use tracing::{debug, instrument};
 
 use crate::errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
 use crate::imports::{Import, NameResolution};
-use crate::late::{ConstantHasGenerics, NoConstantGenericsReason, PathSource, Rib, RibKind};
+use crate::late::{
+    ConstantHasGenerics, DiagMetadata, NoConstantGenericsReason, PathSource, Rib, RibKind,
+};
 use crate::macros::{MacroRulesScope, sub_namespace_match};
 use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingKey, CmResolver, Determinacy,
@@ -295,6 +297,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         finalize: Option<Finalize>,
         ribs: &[Rib<'ra>],
         ignore_binding: Option<NameBinding<'ra>>,
+        diag_metadata: Option<&DiagMetadata<'_>>,
     ) -> Option<LexicalScopeBinding<'ra>> {
         assert!(ns == TypeNS || ns == ValueNS);
         let orig_ident = ident;
@@ -326,6 +329,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     finalize.map(|finalize| finalize.path_span),
                     *original_rib_ident_def,
                     ribs,
+                    diag_metadata,
                 )));
             } else if let RibKind::Block(Some(module)) = rib.kind
                 && let Ok(binding) = self.cm().resolve_ident_in_module_unadjusted(
@@ -1193,6 +1197,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         finalize: Option<Span>,
         original_rib_ident_def: Ident,
         all_ribs: &[Rib<'ra>],
+        diag_metadata: Option<&DiagMetadata<'_>>,
     ) -> Res {
         debug!("validate_res_from_ribs({:?})", res);
         let ribs = &all_ribs[rib_index + 1..];
@@ -1391,13 +1396,26 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     };
 
                     if let Some(span) = finalize {
+                        let item = if let Some(diag_metadata) = diag_metadata
+                            && let Some(current_item) = diag_metadata.current_item
+                        {
+                            let span = current_item
+                                .kind
+                                .ident()
+                                .map(|i| i.span)
+                                .unwrap_or(current_item.span);
+                            Some((span, current_item.kind.clone()))
+                        } else {
+                            None
+                        };
                         self.report_error(
                             span,
-                            ResolutionError::GenericParamsFromOuterItem(
-                                res,
+                            ResolutionError::GenericParamsFromOuterItem {
+                                outer_res: res,
                                 has_generic_params,
                                 def_kind,
-                            ),
+                                inner_item: item,
+                            },
                         );
                     }
                     return Res::Err;
@@ -1466,13 +1484,26 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
                     // This was an attempt to use a const parameter outside its scope.
                     if let Some(span) = finalize {
+                        let item = if let Some(diag_metadata) = diag_metadata
+                            && let Some(current_item) = diag_metadata.current_item
+                        {
+                            let span = current_item
+                                .kind
+                                .ident()
+                                .map(|i| i.span)
+                                .unwrap_or(current_item.span);
+                            Some((span, current_item.kind.clone()))
+                        } else {
+                            None
+                        };
                         self.report_error(
                             span,
-                            ResolutionError::GenericParamsFromOuterItem(
-                                res,
+                            ResolutionError::GenericParamsFromOuterItem {
+                                outer_res: res,
                                 has_generic_params,
                                 def_kind,
-                            ),
+                                inner_item: item,
+                            },
                         );
                     }
                     return Res::Err;
@@ -1501,6 +1532,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             None,
             None,
             ignore_import,
+            None,
         )
     }
     #[instrument(level = "debug", skip(self))]
@@ -1522,6 +1554,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             None,
             ignore_binding,
             ignore_import,
+            None,
         )
     }
 
@@ -1535,6 +1568,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ribs: Option<&PerNS<Vec<Rib<'ra>>>>,
         ignore_binding: Option<NameBinding<'ra>>,
         ignore_import: Option<Import<'ra>>,
+        diag_metadata: Option<&DiagMetadata<'_>>,
     ) -> PathResult<'ra> {
         let mut module = None;
         let mut module_had_parse_errors = false;
@@ -1675,6 +1709,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     finalize,
                     &ribs[ns],
                     ignore_binding,
+                    diag_metadata,
                 ) {
                     // we found a locally-imported or available item/module
                     Some(LexicalScopeBinding::Item(binding)) => Ok(binding),
@@ -1800,6 +1835,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 module,
                                 segment_idx,
                                 ident,
+                                diag_metadata,
                             )
                         },
                     );
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 91d0cae062a7e..0b41a7952797c 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -670,7 +670,7 @@ pub(crate) struct UnnecessaryQualification<'ra> {
 }
 
 #[derive(Default, Debug)]
-struct DiagMetadata<'ast> {
+pub(crate) struct DiagMetadata<'ast> {
     /// The current trait's associated items' ident, used for diagnostic suggestions.
     current_trait_assoc_items: Option<&'ast [Box<AssocItem>]>,
 
@@ -680,8 +680,8 @@ struct DiagMetadata<'ast> {
     /// The current self item if inside an ADT (used for better errors).
     current_self_item: Option<NodeId>,
 
-    /// The current trait (used to suggest).
-    current_item: Option<&'ast Item>,
+    /// The current item being evaluated (used for suggestions and more detail in errors).
+    pub(crate) current_item: Option<&'ast Item>,
 
     /// When processing generic arguments and encountering an unresolved ident not found,
     /// suggest introducing a type or const param depending on the context.
@@ -1460,6 +1460,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             None,
             &self.ribs[ns],
             None,
+            Some(&self.diag_metadata),
         )
     }
 
@@ -1477,6 +1478,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             finalize,
             &self.ribs[ns],
             ignore_binding,
+            Some(&self.diag_metadata),
         )
     }
 
@@ -1496,6 +1498,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             Some(&self.ribs),
             None,
             None,
+            Some(&self.diag_metadata),
         )
     }
 
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f6a4f59cb339a..6b671df433b3d 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -241,7 +241,12 @@ struct BindingError {
 #[derive(Debug)]
 enum ResolutionError<'ra> {
     /// Error E0401: can't use type or const parameters from outer item.
-    GenericParamsFromOuterItem(Res, HasGenericParams, DefKind),
+    GenericParamsFromOuterItem {
+        outer_res: Res,
+        has_generic_params: HasGenericParams,
+        def_kind: DefKind,
+        inner_item: Option<(Span, ast::ItemKind)>,
+    },
     /// Error E0403: the name is already used for a type or const parameter in this generic
     /// parameter list.
     NameAlreadyUsedInParameterList(Ident, Span),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
index 0765434d3c435..e225656af852c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -774,20 +774,31 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     // instead we suggest `T: 'a + 'b` in that case.
                     let hir_generics = self.tcx.hir_get_generics(scope).unwrap();
                     let sugg_span = match hir_generics.bounds_span_for_suggestions(def_id) {
-                        Some((span, open_paren_sp)) => Some((span, true, open_paren_sp)),
+                        Some((span, open_paren_sp)) => {
+                            Some((span, LifetimeSuggestion::NeedsPlus(open_paren_sp)))
+                        }
                         // If `param` corresponds to `Self`, no usable suggestion span.
                         None if generics.has_self && param.index == 0 => None,
                         None => {
+                            let mut colon_flag = false;
                             let span = if let Some(param) =
                                 hir_generics.params.iter().find(|param| param.def_id == def_id)
                                 && let ParamName::Plain(ident) = param.name
                             {
-                                ident.span.shrink_to_hi()
+                                if let Some(sp) = param.colon_span {
+                                    colon_flag = true;
+                                    sp.shrink_to_hi()
+                                } else {
+                                    ident.span.shrink_to_hi()
+                                }
                             } else {
                                 let span = self.tcx.def_span(def_id);
                                 span.shrink_to_hi()
                             };
-                            Some((span, false, None))
+                            match colon_flag {
+                                true => Some((span, LifetimeSuggestion::HasColon)),
+                                false => Some((span, LifetimeSuggestion::NeedsColon)),
+                            }
                         }
                     };
                     (scope, sugg_span)
@@ -811,17 +822,21 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let mut suggs = vec![];
             let lt_name = self.suggest_name_region(generic_param_scope, sub, &mut suggs);
 
-            if let Some((sp, has_lifetimes, open_paren_sp)) = type_param_sugg_span
+            if let Some((sp, suggestion_type)) = type_param_sugg_span
                 && suggestion_scope == type_scope
             {
-                let suggestion =
-                    if has_lifetimes { format!(" + {lt_name}") } else { format!(": {lt_name}") };
-
-                if let Some(open_paren_sp) = open_paren_sp {
-                    suggs.push((open_paren_sp, "(".to_string()));
-                    suggs.push((sp, format!("){suggestion}")));
-                } else {
-                    suggs.push((sp, suggestion))
+                match suggestion_type {
+                    LifetimeSuggestion::NeedsPlus(open_paren_sp) => {
+                        let suggestion = format!(" + {lt_name}");
+                        if let Some(open_paren_sp) = open_paren_sp {
+                            suggs.push((open_paren_sp, "(".to_string()));
+                            suggs.push((sp, format!("){suggestion}")));
+                        } else {
+                            suggs.push((sp, suggestion));
+                        }
+                    }
+                    LifetimeSuggestion::NeedsColon => suggs.push((sp, format!(": {lt_name}"))),
+                    LifetimeSuggestion::HasColon => suggs.push((sp, format!(" {lt_name}"))),
                 }
             } else if let GenericKind::Alias(ref p) = bound_kind
                 && let ty::Projection = p.kind(self.tcx)
@@ -1056,6 +1071,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     }
 }
 
+enum LifetimeSuggestion {
+    NeedsPlus(Option<Span>),
+    NeedsColon,
+    HasColon,
+}
+
 pub(super) fn note_and_explain_region<'tcx>(
     tcx: TyCtxt<'tcx>,
     err: &mut Diag<'_>,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 03d43977df965..d2f2c92dda080 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -839,6 +839,34 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         )) {
             diag.downgrade_to_delayed_bug();
         }
+        for candidate in self.find_similar_impl_candidates(trait_ref) {
+            let CandidateSimilarity::Exact { .. } = candidate.similarity else { continue };
+            let impl_did = candidate.impl_def_id;
+            let trait_did = candidate.trait_ref.def_id;
+            let impl_span = self.tcx.def_span(impl_did);
+            let trait_name = self.tcx.item_name(trait_did);
+
+            if self.tcx.is_const_trait(trait_did) && !self.tcx.is_const_trait_impl(impl_did) {
+                if let Some(impl_did) = impl_did.as_local()
+                    && let item = self.tcx.hir_expect_item(impl_did)
+                    && let hir::ItemKind::Impl(item) = item.kind
+                    && let Some(of_trait) = item.of_trait
+                {
+                    // trait is const, impl is local and not const
+                    diag.span_suggestion_verbose(
+                        of_trait.trait_ref.path.span.shrink_to_lo(),
+                        format!("make the `impl` of trait `{trait_name}` `const`"),
+                        "const ".to_string(),
+                        Applicability::MaybeIncorrect,
+                    );
+                } else {
+                    diag.span_note(
+                        impl_span,
+                        format!("trait `{trait_name}` is implemented but not `const`"),
+                    );
+                }
+            }
+        }
         diag
     }
 
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 4cee77fda4fba..5ba2d92a4596f 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -5,16 +5,16 @@
 //! intrinsics via stable wrapper functions. Use these instead.
 //!
 //! These are the imports making intrinsics available to Rust code. The actual implementations live in the compiler.
-//! Some of these intrinsics are lowered to MIR in <https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_transform/src/lower_intrinsics.rs>.
-//! The remaining intrinsics are implemented for the LLVM backend in <https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs>
-//! and <https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs>,
-//! and for const evaluation in <https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs>.
+//! Some of these intrinsics are lowered to MIR in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/lower_intrinsics.rs>.
+//! The remaining intrinsics are implemented for the LLVM backend in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs>
+//! and <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_llvm/src/intrinsic.rs>,
+//! and for const evaluation in <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/intrinsics.rs>.
 //!
 //! # Const intrinsics
 //!
 //! In order to make an intrinsic unstable usable at compile-time, copy the implementation from
 //! <https://github.com/rust-lang/miri/blob/master/src/intrinsics> to
-//! <https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs>
+//! <https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/intrinsics.rs>
 //! and make the intrinsic declaration below a `const fn`. This should be done in coordination with
 //! wg-const-eval.
 //!
diff --git a/library/core/src/ops/index_range.rs b/library/core/src/ops/index_range.rs
index 507fa9460bea6..84395ddadf2b7 100644
--- a/library/core/src/ops/index_range.rs
+++ b/library/core/src/ops/index_range.rs
@@ -9,7 +9,8 @@ use crate::ub_checks;
 ///
 /// (Normal `Range` code needs to handle degenerate ranges like `10..0`,
 ///  which takes extra checks compared to only handling the canonical form.)
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
+#[derive_const(Clone, Eq, PartialEq)]
 pub(crate) struct IndexRange {
     start: usize,
     end: usize,
@@ -54,7 +55,7 @@ impl IndexRange {
     /// # Safety
     /// - Can only be called when `start < end`, aka when `len > 0`.
     #[inline]
-    unsafe fn next_unchecked(&mut self) -> usize {
+    const unsafe fn next_unchecked(&mut self) -> usize {
         debug_assert!(self.start < self.end);
 
         let value = self.start;
@@ -66,7 +67,7 @@ impl IndexRange {
     /// # Safety
     /// - Can only be called when `start < end`, aka when `len > 0`.
     #[inline]
-    unsafe fn next_back_unchecked(&mut self) -> usize {
+    const unsafe fn next_back_unchecked(&mut self) -> usize {
         debug_assert!(self.start < self.end);
 
         // SAFETY: The range isn't empty, so this cannot overflow
@@ -116,7 +117,7 @@ impl IndexRange {
     }
 
     #[inline]
-    fn assume_range(&self) {
+    const fn assume_range(&self) {
         // SAFETY: This is the type invariant
         unsafe { crate::hint::assert_unchecked(self.start <= self.end) }
     }
diff --git a/library/core/src/ops/range.rs b/library/core/src/ops/range.rs
index 58a9431bd845d..d781f3f7ace4a 100644
--- a/library/core/src/ops/range.rs
+++ b/library/core/src/ops/range.rs
@@ -1,6 +1,6 @@
 use crate::fmt;
 use crate::hash::Hash;
-
+use crate::marker::Destruct;
 /// An unbounded range (`..`).
 ///
 /// `RangeFull` is primarily used as a [slicing index], its shorthand is `..`.
@@ -38,7 +38,8 @@ use crate::hash::Hash;
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeFull"]
 #[doc(alias = "..")]
-#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[derive(Copy, Hash)]
+#[derive_const(Clone, Default, Eq, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFull;
 
@@ -75,7 +76,8 @@ impl fmt::Debug for RangeFull {
 /// ```
 #[lang = "Range"]
 #[doc(alias = "..")]
-#[derive(Clone, Default, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Eq, Hash)]
+#[derive_const(Clone, Default, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Range<Idx> {
     /// The lower bound of the range (inclusive).
@@ -117,10 +119,11 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -144,7 +147,11 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_is_empty", since = "1.47.0")]
-    pub fn is_empty(&self) -> bool {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn is_empty(&self) -> bool
+    where
+        Idx: [const] PartialOrd<Idx>,
+    {
         !(self.start < self.end)
     }
 }
@@ -184,7 +191,8 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
 /// ```
 #[lang = "RangeFrom"]
 #[doc(alias = "..")]
-#[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Eq, Hash)]
+#[derive_const(Clone, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
@@ -217,10 +225,11 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -266,7 +275,8 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeTo"]
 #[doc(alias = "..")]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Eq, Hash)]
+#[derive_const(Clone, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeTo<Idx> {
     /// The upper bound of the range (exclusive).
@@ -299,10 +309,11 @@ impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -340,7 +351,8 @@ impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
 /// ```
 #[lang = "RangeInclusive"]
 #[doc(alias = "..=")]
-#[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Clone, Hash)]
+#[derive_const(Eq, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "inclusive_range", since = "1.26.0")]
 pub struct RangeInclusive<Idx> {
     // Note that the fields here are not public to allow changing the
@@ -506,10 +518,11 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -542,7 +555,11 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// ```
     #[stable(feature = "range_is_empty", since = "1.47.0")]
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn is_empty(&self) -> bool
+    where
+        Idx: [const] PartialOrd,
+    {
         self.exhausted || !(self.start <= self.end)
     }
 }
@@ -587,7 +604,8 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeToInclusive"]
 #[doc(alias = "..=")]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Hash)]
+#[derive(Clone, PartialEq, Eq)]
 #[stable(feature = "inclusive_range", since = "1.26.0")]
 pub struct RangeToInclusive<Idx> {
     /// The upper bound of the range (inclusive)
@@ -620,10 +638,11 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
     /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -668,7 +687,8 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 ///
 /// [`BTreeMap::range`]: ../../std/collections/btree_map/struct.BTreeMap.html#method.range
 #[stable(feature = "collections_bound", since = "1.17.0")]
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(Clone, Eq, PartialEq)]
 pub enum Bound<T> {
     /// An inclusive bound.
     #[stable(feature = "collections_bound", since = "1.17.0")]
@@ -685,7 +705,8 @@ impl<T> Bound<T> {
     /// Converts from `&Bound<T>` to `Bound<&T>`.
     #[inline]
     #[stable(feature = "bound_as_ref_shared", since = "1.65.0")]
-    pub fn as_ref(&self) -> Bound<&T> {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn as_ref(&self) -> Bound<&T> {
         match *self {
             Included(ref x) => Included(x),
             Excluded(ref x) => Excluded(x),
@@ -696,7 +717,7 @@ impl<T> Bound<T> {
     /// Converts from `&mut Bound<T>` to `Bound<&mut T>`.
     #[inline]
     #[unstable(feature = "bound_as_ref", issue = "80996")]
-    pub fn as_mut(&mut self) -> Bound<&mut T> {
+    pub const fn as_mut(&mut self) -> Bound<&mut T> {
         match *self {
             Included(ref mut x) => Included(x),
             Excluded(ref mut x) => Excluded(x),
@@ -778,7 +799,11 @@ impl<T: Clone> Bound<&T> {
     /// ```
     #[must_use = "`self` will be dropped if the result is not used"]
     #[stable(feature = "bound_cloned", since = "1.55.0")]
-    pub fn cloned(self) -> Bound<T> {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn cloned(self) -> Bound<T>
+    where
+        T: [const] Clone,
+    {
         match self {
             Bound::Unbounded => Bound::Unbounded,
             Bound::Included(x) => Bound::Included(x.clone()),
@@ -791,6 +816,8 @@ impl<T: Clone> Bound<&T> {
 /// by range syntax like `..`, `a..`, `..b`, `..=c`, `d..e`, or `f..=g`.
 #[stable(feature = "collections_range", since = "1.28.0")]
 #[rustc_diagnostic_item = "RangeBounds"]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
 pub trait RangeBounds<T: ?Sized> {
     /// Start index bound.
     ///
@@ -841,8 +868,8 @@ pub trait RangeBounds<T: ?Sized> {
     #[stable(feature = "range_contains", since = "1.35.0")]
     fn contains<U>(&self, item: &U) -> bool
     where
-        T: PartialOrd<U>,
-        U: ?Sized + PartialOrd<T>,
+        T: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<T>,
     {
         (match self.start_bound() {
             Included(start) => start <= item,
@@ -909,7 +936,7 @@ pub trait RangeBounds<T: ?Sized> {
     #[unstable(feature = "range_bounds_is_empty", issue = "137300")]
     fn is_empty(&self) -> bool
     where
-        T: PartialOrd,
+        T: [const] PartialOrd,
     {
         !match (self.start_bound(), self.end_bound()) {
             (Unbounded, _) | (_, Unbounded) => true,
@@ -927,7 +954,9 @@ pub trait RangeBounds<T: ?Sized> {
 /// `IntoBounds` is implemented by Rust’s built-in range types, produced
 /// by range syntax like `..`, `a..`, `..b`, `..=c`, `d..e`, or `f..=g`.
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-pub trait IntoBounds<T>: RangeBounds<T> {
+#[const_trait]
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+pub trait IntoBounds<T>: [const] RangeBounds<T> {
     /// Convert this range into the start and end bounds.
     /// Returns `(start_bound, end_bound)`.
     ///
@@ -973,8 +1002,8 @@ pub trait IntoBounds<T>: RangeBounds<T> {
     fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)
     where
         Self: Sized,
-        T: Ord,
-        R: Sized + IntoBounds<T>,
+        T: [const] Ord + [const] Destruct,
+        R: Sized + [const] IntoBounds<T>,
     {
         let (self_start, self_end) = IntoBounds::into_bounds(self);
         let (other_start, other_end) = IntoBounds::into_bounds(other);
@@ -1017,7 +1046,8 @@ pub trait IntoBounds<T>: RangeBounds<T> {
 use self::Bound::{Excluded, Included, Unbounded};
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T: ?Sized> RangeBounds<T> for RangeFull {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T: ?Sized> const RangeBounds<T> for RangeFull {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -1027,14 +1057,16 @@ impl<T: ?Sized> RangeBounds<T> for RangeFull {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeFull {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeFull {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Unbounded, Unbounded)
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeFrom<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -1044,14 +1076,16 @@ impl<T> RangeBounds<T> for RangeFrom<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeFrom<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Included(self.start), Unbounded)
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeTo<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeTo<T> {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -1061,14 +1095,16 @@ impl<T> RangeBounds<T> for RangeTo<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeTo<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeTo<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Unbounded, Excluded(self.end))
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for Range<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for Range<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -1078,14 +1114,16 @@ impl<T> RangeBounds<T> for Range<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for Range<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for Range<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Included(self.start), Excluded(self.end))
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeInclusive<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -1101,7 +1139,8 @@ impl<T> RangeBounds<T> for RangeInclusive<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeInclusive<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (
             Included(self.start),
@@ -1117,7 +1156,8 @@ impl<T> IntoBounds<T> for RangeInclusive<T> {
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeToInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeToInclusive<T> {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -1127,14 +1167,16 @@ impl<T> RangeBounds<T> for RangeToInclusive<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeToInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeToInclusive<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Unbounded, Included(self.end))
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for (Bound<T>, Bound<T>) {
     fn start_bound(&self) -> Bound<&T> {
         match *self {
             (Included(ref start), _) => Included(start),
@@ -1153,14 +1195,16 @@ impl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for (Bound<T>, Bound<T>) {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for (Bound<T>, Bound<T>) {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         self
     }
 }
 
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>) {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<'a, T: ?Sized + 'a> const RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>) {
     fn start_bound(&self) -> Bound<&T> {
         self.0
     }
@@ -1177,7 +1221,8 @@ impl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>) {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..` with `(Bound::Included(start), Bound::Unbounded)`.
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeFrom<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeFrom<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -1193,7 +1238,8 @@ impl<T> RangeBounds<T> for RangeFrom<&T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `..end` with `(Bound::Unbounded, Bound::Excluded(end))`.
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeTo<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeTo<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -1209,7 +1255,8 @@ impl<T> RangeBounds<T> for RangeTo<&T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..end` with `(Bound::Included(start), Bound::Excluded(end))`.
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for Range<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for Range<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -1225,7 +1272,8 @@ impl<T> RangeBounds<T> for Range<&T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..=end` with `(Bound::Included(start), Bound::Included(end))`.
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeInclusive<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeInclusive<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -1241,7 +1289,8 @@ impl<T> RangeBounds<T> for RangeInclusive<&T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `..=end` with `(Bound::Unbounded, Bound::Included(end))`.
 #[stable(feature = "collections_range", since = "1.28.0")]
-impl<T> RangeBounds<T> for RangeToInclusive<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeToInclusive<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -1270,6 +1319,8 @@ pub enum OneSidedRangeBound {
 /// Types that implement `OneSidedRange<T>` must return `Bound::Unbounded`
 /// from one of `RangeBounds::start_bound` or `RangeBounds::end_bound`.
 #[unstable(feature = "one_sided_range", issue = "69780")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
 pub trait OneSidedRange<T>: RangeBounds<T> {
     /// An internal-only helper function for `split_off` and
     /// `split_off_mut` that returns the bound of the one-sided range.
@@ -1277,7 +1328,8 @@ pub trait OneSidedRange<T>: RangeBounds<T> {
 }
 
 #[unstable(feature = "one_sided_range", issue = "69780")]
-impl<T> OneSidedRange<T> for RangeTo<T>
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const OneSidedRange<T> for RangeTo<T>
 where
     Self: RangeBounds<T>,
 {
@@ -1287,7 +1339,8 @@ where
 }
 
 #[unstable(feature = "one_sided_range", issue = "69780")]
-impl<T> OneSidedRange<T> for RangeFrom<T>
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const OneSidedRange<T> for RangeFrom<T>
 where
     Self: RangeBounds<T>,
 {
@@ -1297,7 +1350,8 @@ where
 }
 
 #[unstable(feature = "one_sided_range", issue = "69780")]
-impl<T> OneSidedRange<T> for RangeToInclusive<T>
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const OneSidedRange<T> for RangeToInclusive<T>
 where
     Self: RangeBounds<T>,
 {
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index a096a8ceafc87..96c56e96b3ebe 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -118,10 +118,11 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// ```
     #[inline]
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -151,13 +152,18 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// ```
     #[inline]
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub fn is_empty(&self) -> bool {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn is_empty(&self) -> bool
+    where
+        Idx: [const] PartialOrd,
+    {
         !(self.start < self.end)
     }
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for Range<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for Range<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -173,7 +179,8 @@ impl<T> RangeBounds<T> for Range<T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..end` with `(Bound::Included(start), Bound::Excluded(end))`.
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for Range<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for Range<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -184,7 +191,8 @@ impl<T> RangeBounds<T> for Range<&T> {
 
 // #[unstable(feature = "range_into_bounds", issue = "136903")]
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> IntoBounds<T> for Range<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for Range<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Included(self.start), Excluded(self.end))
     }
@@ -271,10 +279,11 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// ```
     #[inline]
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -304,7 +313,11 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// ```
     #[unstable(feature = "new_range_api", issue = "125687")]
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn is_empty(&self) -> bool
+    where
+        Idx: [const] PartialOrd,
+    {
         !(self.start <= self.last)
     }
 }
@@ -342,7 +355,8 @@ impl RangeInclusive<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeInclusive<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -358,7 +372,8 @@ impl<T> RangeBounds<T> for RangeInclusive<T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..=end` with `(Bound::Included(start), Bound::Included(end))`.
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for RangeInclusive<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeInclusive<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -369,7 +384,8 @@ impl<T> RangeBounds<T> for RangeInclusive<&T> {
 
 // #[unstable(feature = "range_into_bounds", issue = "136903")]
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> IntoBounds<T> for RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeInclusive<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Included(self.start), Included(self.last))
     }
@@ -485,17 +501,19 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
     /// ```
     #[inline]
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeFrom<T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
@@ -511,7 +529,8 @@ impl<T> RangeBounds<T> for RangeFrom<T> {
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..` with `(Bound::Included(start), Bound::Unbounded)`.
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for RangeFrom<&T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeFrom<&T> {
     fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
@@ -522,7 +541,8 @@ impl<T> RangeBounds<T> for RangeFrom<&T> {
 
 // #[unstable(feature = "range_into_bounds", issue = "136903")]
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> IntoBounds<T> for RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeFrom<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Included(self.start), Unbounded)
     }
@@ -620,10 +640,11 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
     /// ```
     #[inline]
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub fn contains<U>(&self, item: &U) -> bool
+    #[rustc_const_unstable(feature = "const_range", issue = "none")]
+    pub const fn contains<U>(&self, item: &U) -> bool
     where
-        Idx: PartialOrd<U>,
-        U: ?Sized + PartialOrd<Idx>,
+        Idx: [const] PartialOrd<U>,
+        U: ?Sized + [const] PartialOrd<Idx>,
     {
         <Self as RangeBounds<Idx>>::contains(self, item)
     }
@@ -633,7 +654,8 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 // because underflow would be possible with (..0).into()
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> RangeBounds<T> for RangeToInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const RangeBounds<T> for RangeToInclusive<T> {
     fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
@@ -643,7 +665,8 @@ impl<T> RangeBounds<T> for RangeToInclusive<T> {
 }
 
 #[unstable(feature = "range_into_bounds", issue = "136903")]
-impl<T> IntoBounds<T> for RangeToInclusive<T> {
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+impl<T> const IntoBounds<T> for RangeToInclusive<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
         (Unbounded, Included(self.last))
     }
diff --git a/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
index 42916558b5fc4..3e8c553f9f159 100644
--- a/library/core/src/slice/ascii.rs
+++ b/library/core/src/slice/ascii.rs
@@ -3,7 +3,10 @@
 use core::ascii::EscapeDefault;
 
 use crate::fmt::{self, Write};
-#[cfg(not(all(target_arch = "x86_64", target_feature = "sse2")))]
+#[cfg(not(any(
+    all(target_arch = "x86_64", target_feature = "sse2"),
+    all(target_arch = "loongarch64", target_feature = "lsx")
+)))]
 use crate::intrinsics::const_eval_select;
 use crate::{ascii, iter, ops};
 
@@ -359,7 +362,10 @@ pub const fn is_ascii_simple(mut bytes: &[u8]) -> bool {
 ///
 /// If any of these loads produces something for which `contains_nonascii`
 /// (above) returns true, then we know the answer is false.
-#[cfg(not(all(target_arch = "x86_64", target_feature = "sse2")))]
+#[cfg(not(any(
+    all(target_arch = "x86_64", target_feature = "sse2"),
+    all(target_arch = "loongarch64", target_feature = "lsx")
+)))]
 #[inline]
 #[rustc_allow_const_fn_unstable(const_eval_select)] // fallback impl has same behavior
 const fn is_ascii(s: &[u8]) -> bool {
@@ -457,12 +463,15 @@ const fn is_ascii(s: &[u8]) -> bool {
     )
 }
 
-/// ASCII test optimized to use the `pmovmskb` instruction available on `x86-64`
-/// platforms.
+/// ASCII test optimized to use the `pmovmskb` instruction on `x86-64` and the
+/// `vmskltz.b` instruction on `loongarch64`.
 ///
 /// Other platforms are not likely to benefit from this code structure, so they
 /// use SWAR techniques to test for ASCII in `usize`-sized chunks.
-#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+#[cfg(any(
+    all(target_arch = "x86_64", target_feature = "sse2"),
+    all(target_arch = "loongarch64", target_feature = "lsx")
+))]
 #[inline]
 const fn is_ascii(bytes: &[u8]) -> bool {
     // Process chunks of 32 bytes at a time in the fast path to enable
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index a9806060d3d81..aad046a7e5a94 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -1,6 +1,7 @@
 //! Indexing implementations for `[T]`.
 
 use crate::intrinsics::slice_get_unchecked;
+use crate::marker::Destruct;
 use crate::panic::const_panic;
 use crate::ub_checks::assert_unsafe_precondition;
 use crate::{ops, range};
@@ -899,9 +900,10 @@ unsafe impl<T> const SliceIndex<[T]> for range::RangeToInclusive<usize> {
 #[track_caller]
 #[unstable(feature = "slice_range", issue = "76393")]
 #[must_use]
-pub fn range<R>(range: R, bounds: ops::RangeTo<usize>) -> ops::Range<usize>
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+pub const fn range<R>(range: R, bounds: ops::RangeTo<usize>) -> ops::Range<usize>
 where
-    R: ops::RangeBounds<usize>,
+    R: [const] ops::RangeBounds<usize> + [const] Destruct,
 {
     let len = bounds.end;
 
@@ -984,7 +986,7 @@ where
 
 /// Converts a pair of `ops::Bound`s into `ops::Range` without performing any
 /// bounds checking or (in debug) overflow checking.
-pub(crate) fn into_range_unchecked(
+pub(crate) const fn into_range_unchecked(
     len: usize,
     (start, end): (ops::Bound<usize>, ops::Bound<usize>),
 ) -> ops::Range<usize> {
@@ -1004,7 +1006,8 @@ pub(crate) fn into_range_unchecked(
 
 /// Converts pair of `ops::Bound`s into `ops::Range`.
 /// Returns `None` on overflowing indices.
-pub(crate) fn into_range(
+#[rustc_const_unstable(feature = "const_range", issue = "none")]
+pub(crate) const fn into_range(
     len: usize,
     (start, end): (ops::Bound<usize>, ops::Bound<usize>),
 ) -> Option<ops::Range<usize>> {
diff --git a/library/std/src/os/unix/net/tests.rs b/library/std/src/os/unix/net/tests.rs
index 4666b5e3c6c18..d88c97113efeb 100644
--- a/library/std/src/os/unix/net/tests.rs
+++ b/library/std/src/os/unix/net/tests.rs
@@ -24,6 +24,7 @@ macro_rules! or_panic {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn basic() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -51,6 +52,7 @@ fn basic() {
 }
 
 #[test]
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn vectored() {
     let (mut s1, mut s2) = or_panic!(UnixStream::pair());
 
@@ -71,6 +73,7 @@ fn vectored() {
 }
 
 #[test]
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn pair() {
     let msg1 = b"hello";
     let msg2 = b"world!";
@@ -95,6 +98,7 @@ fn pair() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn try_clone() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -122,6 +126,7 @@ fn try_clone() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn iter() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -144,6 +149,7 @@ fn iter() {
 }
 
 #[test]
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn long_path() {
     let dir = tmpdir();
     let socket_path = dir.path().join(
@@ -173,6 +179,7 @@ fn long_path() {
 #[cfg(not(target_os = "nto"))]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn timeouts() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -202,6 +209,7 @@ fn timeouts() {
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_read_timeout() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -223,6 +231,7 @@ fn test_read_timeout() {
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_read_with_timeout() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -252,6 +261,7 @@ fn test_read_with_timeout() {
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_stream_timeout_zero_duration() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -272,6 +282,7 @@ fn test_unix_stream_timeout_zero_duration() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -290,6 +301,7 @@ fn test_unix_datagram() {
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin autobinds an address
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unnamed_unix_datagram() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -308,6 +320,7 @@ fn test_unnamed_unix_datagram() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram_connect_to_recv_addr() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -334,6 +347,7 @@ fn test_unix_datagram_connect_to_recv_addr() {
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
 #[cfg_attr(target_os = "cygwin", ignore)] // Cygwin autobinds an address
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_connect_unix_datagram() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -361,6 +375,7 @@ fn test_connect_unix_datagram() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram_recv() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -378,6 +393,7 @@ fn test_unix_datagram_recv() {
 }
 
 #[test]
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn datagram_pair() {
     let msg1 = b"hello";
     let msg2 = b"world!";
@@ -404,6 +420,7 @@ fn datagram_pair() {
 // when passed zero Durations
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram_timeout_zero_duration() {
     let dir = tmpdir();
     let path = dir.path().join("sock");
@@ -562,6 +579,7 @@ fn test_abstract_no_pathname_and_not_unnamed() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_stream_peek() {
     let (txdone, rxdone) = crate::sync::mpsc::channel();
 
@@ -595,6 +613,7 @@ fn test_unix_stream_peek() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram_peek() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock");
@@ -620,6 +639,7 @@ fn test_unix_datagram_peek() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "vxworks", ignore = "Unix sockets are not implemented in VxWorks")]
 fn test_unix_datagram_peek_from() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock");
diff --git a/library/std/src/sys/thread/unix.rs b/library/std/src/sys/thread/unix.rs
index 2a3e3a9715f80..9b26262bc80dc 100644
--- a/library/std/src/sys/thread/unix.rs
+++ b/library/std/src/sys/thread/unix.rs
@@ -7,7 +7,7 @@
     target_os = "aix",
 )))]
 use crate::ffi::CStr;
-use crate::mem::{self, ManuallyDrop};
+use crate::mem::{self, DropGuard, ManuallyDrop};
 use crate::num::NonZero;
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use crate::sys::weak::dlsym;
@@ -52,10 +52,13 @@ impl Thread {
         name: Option<&str>,
         f: Box<dyn FnOnce()>,
     ) -> io::Result<Thread> {
-        let data = Box::into_raw(Box::new(ThreadData { name: name.map(Box::from), f }));
-        let mut native: libc::pthread_t = mem::zeroed();
+        let data = Box::new(ThreadData { name: name.map(Box::from), f });
+
         let mut attr: mem::MaybeUninit<libc::pthread_attr_t> = mem::MaybeUninit::uninit();
         assert_eq!(libc::pthread_attr_init(attr.as_mut_ptr()), 0);
+        let mut attr = DropGuard::new(&mut attr, |attr| {
+            assert_eq!(libc::pthread_attr_destroy(attr.as_mut_ptr()), 0)
+        });
 
         #[cfg(any(target_os = "espidf", target_os = "nuttx"))]
         if stack > 0 {
@@ -90,8 +93,6 @@ impl Thread {
                     // on the stack size, in which case we can only gracefully return
                     // an error here.
                     if libc::pthread_attr_setstacksize(attr.as_mut_ptr(), stack_size) != 0 {
-                        assert_eq!(libc::pthread_attr_destroy(attr.as_mut_ptr()), 0);
-                        drop(Box::from_raw(data));
                         return Err(io::const_error!(
                             io::ErrorKind::InvalidInput,
                             "invalid stack size"
@@ -101,19 +102,16 @@ impl Thread {
             };
         }
 
+        let data = Box::into_raw(data);
+        let mut native: libc::pthread_t = mem::zeroed();
         let ret = libc::pthread_create(&mut native, attr.as_ptr(), thread_start, data as *mut _);
-        // Note: if the thread creation fails and this assert fails, then p will
-        // be leaked. However, an alternative design could cause double-free
-        // which is clearly worse.
-        assert_eq!(libc::pthread_attr_destroy(attr.as_mut_ptr()), 0);
-
-        return if ret != 0 {
-            // The thread failed to start and as a result p was not consumed. Therefore, it is
-            // safe to reconstruct the box so that it gets deallocated.
+        return if ret == 0 {
+            Ok(Thread { id: native })
+        } else {
+            // The thread failed to start and as a result `data` was not consumed.
+            // Therefore, it is safe to reconstruct the box so that it gets deallocated.
             drop(Box::from_raw(data));
             Err(io::Error::from_raw_os_error(ret))
-        } else {
-            Ok(Thread { id: native })
         };
 
         extern "C" fn thread_start(data: *mut libc::c_void) -> *mut libc::c_void {
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index dd30f05b72832..d646e3badb415 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1611,7 +1611,7 @@ impl Build {
         // If available, we read the beta revision from that file.
         // This only happens when building from a source tarball when Git should not be used.
         let count = extract_beta_rev_from_file(self.src.join("version")).unwrap_or_else(|| {
-            // Figure out how many merge commits happened since we branched off master.
+            // Figure out how many merge commits happened since we branched off main.
             // That's our beta number!
             // (Note that we use a `..` range, not the `...` symmetric difference.)
             helpers::git(Some(&self.src))
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile
new file mode 100644
index 0000000000000..f0314854411f2
--- /dev/null
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile
@@ -0,0 +1,66 @@
+FROM ubuntu:25.10
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  bzip2 \
+  g++ \
+  gcc-multilib \
+  make \
+  ninja-build \
+  file \
+  curl \
+  ca-certificates \
+  python3 \
+  git \
+  cmake \
+  sudo \
+  gdb \
+  llvm-21-tools \
+  llvm-21-dev \
+  libedit-dev \
+  libssl-dev \
+  pkg-config \
+  zlib1g-dev \
+  xz-utils \
+  nodejs \
+  mingw-w64 \
+  # libgccjit dependencies
+  flex \
+  libmpfr-dev \
+  libgmp-dev \
+  libmpc3 \
+  libmpc-dev \
+  && rm -rf /var/lib/apt/lists/*
+
+# Install powershell (universal package) so we can test x.ps1 on Linux
+# FIXME: need a "universal" version that supports libicu74, but for now it still works to ignore that dep.
+RUN curl -sL "https://github.com/PowerShell/PowerShell/releases/download/v7.3.1/powershell_7.3.1-1.deb_amd64.deb" > powershell.deb && \
+    dpkg --ignore-depends=libicu72 -i powershell.deb && \
+    rm -f powershell.deb
+
+COPY scripts/sccache.sh /scripts/
+RUN sh /scripts/sccache.sh
+
+# We are disabling CI LLVM since this builder is intentionally using a host
+# LLVM, rather than the typical src/llvm-project LLVM.
+ENV NO_DOWNLOAD_CI_LLVM 1
+ENV EXTERNAL_LLVM 1
+
+# Using llvm-link-shared due to libffi issues -- see #34486
+ENV RUST_CONFIGURE_ARGS \
+      --build=x86_64-unknown-linux-gnu \
+      --llvm-root=/usr/lib/llvm-21 \
+      --enable-llvm-link-shared \
+      --set rust.randomize-layout=true \
+      --set rust.thin-lto-import-instr-limit=10
+
+COPY scripts/shared.sh /scripts/
+
+COPY scripts/x86_64-gnu-llvm.sh /scripts/
+COPY scripts/x86_64-gnu-llvm2.sh /scripts/
+COPY scripts/x86_64-gnu-llvm3.sh /scripts/
+COPY scripts/stage_2_test_set1.sh /scripts/
+COPY scripts/stage_2_test_set2.sh /scripts/
+
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index eeef94483fda0..33de0b09d94d1 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -162,7 +162,7 @@ optional:
       IMAGE: pr-check-1
     <<: *job-linux-4c
 
-# Main CI jobs that have to be green to merge a commit into master.
+# Main CI jobs that have to be green to merge a commit into the default branch.
 #
 # These jobs automatically inherit envs.auto, to avoid repeating it in each job
 # definition.
@@ -404,6 +404,31 @@ auto:
       DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
     <<: *job-linux-4c
 
+  # The x86_64-gnu-llvm-21 job is split into multiple jobs to run tests in parallel.
+  # x86_64-gnu-llvm-21-1 skips tests that run in x86_64-gnu-llvm-21-{2,3}.
+  - name: x86_64-gnu-llvm-21-1
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-21
+      DOCKER_SCRIPT: stage_2_test_set2.sh
+    <<: *job-linux-4c
+
+  # Skip tests that run in x86_64-gnu-llvm-21-{1,3}
+  - name: x86_64-gnu-llvm-21-2
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-21
+      DOCKER_SCRIPT: x86_64-gnu-llvm2.sh
+    <<: *job-linux-4c
+
+  # Skip tests that run in x86_64-gnu-llvm-21-{1,2}
+  - name: x86_64-gnu-llvm-21-3
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-21
+      DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
+    <<: *job-linux-4c
+
   - name: x86_64-gnu-nopt
     <<: *job-linux-4c
 
diff --git a/src/ci/run.sh b/src/ci/run.sh
index c9d81f1ff510f..b486f0525f40d 100755
--- a/src/ci/run.sh
+++ b/src/ci/run.sh
@@ -106,7 +106,7 @@ fi
 
 # Always set the release channel for bootstrap; this is normally not important (i.e., only dist
 # builds would seem to matter) but in practice bootstrap wants to know whether we're targeting
-# master, beta, or stable with a build to determine whether to run some checks (notably toolstate).
+# main, beta, or stable with a build to determine whether to run some checks (notably toolstate).
 export RUST_RELEASE_CHANNEL=$(releaseChannel)
 RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --release-channel=$RUST_RELEASE_CHANNEL"
 
diff --git a/src/ci/scripts/checkout-submodules.sh b/src/ci/scripts/checkout-submodules.sh
index 3b646587dc28d..5a422afc42b46 100755
--- a/src/ci/scripts/checkout-submodules.sh
+++ b/src/ci/scripts/checkout-submodules.sh
@@ -17,7 +17,7 @@ ci_dir=$(cd $(dirname $0) && pwd)/..
 # On the beta channel we'll be automatically calculating the prerelease version
 # via the git history, so unshallow our shallow clone from CI.
 if [ "$(releaseChannel)" = "beta" ]; then
-  git fetch origin --unshallow beta master
+  git fetch origin --unshallow beta HEAD
 fi
 
 function fetch_github_commit_archive {
diff --git a/src/ci/scripts/verify-backported-commits.sh b/src/ci/scripts/verify-backported-commits.sh
index d3da6d1ac915a..e7d2692e1187d 100755
--- a/src/ci/scripts/verify-backported-commits.sh
+++ b/src/ci/scripts/verify-backported-commits.sh
@@ -1,5 +1,6 @@
 #!/bin/bash
-# Ensure commits in beta are in master & commits in stable are in beta + master.
+# Ensure commits in beta are in the default branch & commits in stable are in beta + the default
+# branch.
 set -euo pipefail
 IFS=$'\n\t'
 
@@ -19,11 +20,11 @@ verify_backported_commits_main() {
   fi
 
   if [[ $ci_base_branch == "beta" ]]; then
-    verify_cherries master "$BETA_LIMIT" \
+    verify_cherries HEAD "$BETA_LIMIT" \
       || exit 1
 
   elif [[ $ci_base_branch == "stable" ]]; then
-    (verify_cherries master "$STABLE_LIMIT" \
+    (verify_cherries HEAD "$STABLE_LIMIT" \
       & verify_cherries beta "$STABLE_LIMIT") \
       || exit 1
 
@@ -64,7 +65,7 @@ verify_cherries() {
       continue
     fi
 
-    if ! is_in_master "$backport_sha"; then
+    if ! is_in_default_branch "$backport_sha"; then
       bad_backports+=("$sha")
       continue
     fi
@@ -85,7 +86,7 @@ verify_cherries() {
         done
         echo
         echo "do not match any commits in \`$1\`. If this was intended, add the text"
-        echo '\`backport-of: <SHA of a commit already in master>\`'
+        echo '\`backport-of: <SHA of a commit already in the default branch>\`'
         echo 'somewhere in the message of each of these commits.'
         echo
         failure=1
@@ -101,7 +102,7 @@ verify_cherries() {
         done
         echo
         echo 'have commit messages marked \`backport-of: <SHA>\`, but the SHA is not in'
-        echo '\`master\`.'
+        echo 'the default branch.'
         echo
         failure=1
   fi
@@ -132,11 +133,11 @@ get_backport() {
     | sed -n '/^.*backport-of:\s\?\([a-f0-9]\+\|nothing\).*/{s//\1/p;q}'
 }
 
-# Check if a commit is in master.
+# Check if a commit is in the default branch.
 #
 # $1 = <sha>
-is_in_master() {
-  git merge-base --is-ancestor "$1" origin/master 2> /dev/null
+is_in_default_branch() {
+  git merge-base --is-ancestor "$1" origin/HEAD 2> /dev/null
 }
 
 verify_backported_commits_main
diff --git a/src/doc/rustc-dev-guide/src/appendix/code-index.md b/src/doc/rustc-dev-guide/src/appendix/code-index.md
index 4ddb58b0c39ba..0795d83b2e9ad 100644
--- a/src/doc/rustc-dev-guide/src/appendix/code-index.md
+++ b/src/doc/rustc-dev-guide/src/appendix/code-index.md
@@ -12,7 +12,7 @@ Item            |  Kind    | Short description           | Chapter            |
 `rustc_hir::Crate` | struct | A more abstract, compiler-friendly form of a crate's AST | [The Hir] | [compiler/rustc_hir/src/hir.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/struct.Crate.html)
 `DefId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/def_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html)
 `Diag` | struct | A struct for a compiler diagnostic, such as an error or lint | [Emitting Diagnostics] | [compiler/rustc_errors/src/diagnostic.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Diag.html)
-`DocContext` | struct | A state container used by rustdoc when crawling through a crate to gather its documentation | [Rustdoc] | [src/librustdoc/core.rs](https://github.com/rust-lang/rust/blob/master/src/librustdoc/core.rs)
+`DocContext` | struct | A state container used by rustdoc when crawling through a crate to gather its documentation | [Rustdoc] | [src/librustdoc/core.rs](https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/core.rs)
 `HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir_id/src/lib.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.HirId.html)
 `Lexer` | struct | This is the lexer used during parsing. It consumes characters from the raw source code being compiled and produces a series of tokens for use by the rest of the parser | [The parser] |  [compiler/rustc_parse/src/lexer/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.Lexer.html)
 `NodeId` | struct | One of four types of HIR node identifiers. Being phased out | [Identifiers in the HIR] | [compiler/rustc_ast/src/ast.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html)
diff --git a/src/doc/rustc-dev-guide/src/appendix/humorust.md b/src/doc/rustc-dev-guide/src/appendix/humorust.md
index 8681512ed56a9..ea8623c962c0c 100644
--- a/src/doc/rustc-dev-guide/src/appendix/humorust.md
+++ b/src/doc/rustc-dev-guide/src/appendix/humorust.md
@@ -3,7 +3,7 @@
 What's a project without a sense of humor? And frankly some of these are
 enlightening?
 
-- [Weird exprs test](https://github.com/rust-lang/rust/blob/master/tests/ui/expr/weird-exprs.rs)
+- [Weird exprs test](https://github.com/rust-lang/rust/blob/HEAD/tests/ui/expr/weird-exprs.rs)
 - [Ferris Rap](https://fitzgen.com/2018/12/13/rust-raps.html)
 - [The Genesis of Generic Germination](https://github.com/rust-lang/rust/pull/53645#issue-210543221)
 - [The Bastion of the Turbofish test](https://github.com/rust-lang/rust/blob/79d8a0fcefa5134db2a94739b1d18daa01fc6e9f/src/test/ui/bastion-of-the-turbofish.rs)
diff --git a/src/doc/rustc-dev-guide/src/attributes.md b/src/doc/rustc-dev-guide/src/attributes.md
index aae856348af17..2a812a17ddb85 100644
--- a/src/doc/rustc-dev-guide/src/attributes.md
+++ b/src/doc/rustc-dev-guide/src/attributes.md
@@ -35,7 +35,7 @@ Definitions of non-builtin attributes take two forms:
 2. AST-based attributes, defined in the standard library. These attributes have special 'stub'
    macros defined in places like [`library/core/src/macros/mod.rs`][core_macros].
 
-[core_macros]:  https://github.com/rust-lang/rust/blob/master/library/core/src/macros/mod.rs
+[core_macros]:  https://github.com/rust-lang/rust/blob/HEAD/library/core/src/macros/mod.rs
 
 These definitions exist to allow the macros to participate in typical path-based resolution - they
 can be imported, re-exported, and renamed just like any other item definition. However, the body of
diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index ebef15d40baf5..70deeebf8bec4 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -224,7 +224,7 @@ keep in mind while going through them:
 
 [rust-lang/llvm-project repository]: https://github.com/rust-lang/llvm-project
 [llvm/llvm-project repository]: https://github.com/llvm/llvm-project
-[`llvm-wrapper`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_llvm/llvm-wrapper
+[`llvm-wrapper`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_llvm/llvm-wrapper
 [wg-llvm]: https://rust-lang.zulipchat.com/#narrow/stream/187780-t-compiler.2Fwg-llvm
 [Dev Desktops]: https://forge.rust-lang.org/infra/docs/dev-desktop.html
 [backport process]: https://llvm.org/docs/GitHub.html#backporting-fixes-to-the-release-branches
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md
index 0d55ab955836e..ba67bec45b65e 100644
--- a/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md
@@ -81,7 +81,7 @@ For each region we maintain a set storing what elements are present in its value
 efficient, we give each kind of element an index, the `RegionElementIndex`, and
 use sparse bitsets).
 
-[ri]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_borrowck/src/region_infer
+[ri]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_borrowck/src/region_infer
 
 The kinds of region elements are as follows:
 
diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/how-bootstrap-does-it.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/how-bootstrap-does-it.md
index 6b32845f0684e..4d301b3abae1a 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/how-bootstrap-does-it.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/how-bootstrap-does-it.md
@@ -39,12 +39,12 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
 
 There's a couple of preliminary steps before core Bootstrap code is reached:
 
-1. Shell script or `make`: [`./x`](https://github.com/rust-lang/rust/blob/master/x) or [`./x.ps1`](https://github.com/rust-lang/rust/blob/master/x.ps1) or `make`
-2. Convenience wrapper script: [`x.py`](https://github.com/rust-lang/rust/blob/master/x.py)
-3. [`src/bootstrap/bootstrap.py`](https://github.com/rust-lang/rust/blob/master/src/bootstrap/bootstrap.py)
-4. [`src/bootstrap/src/bin/main.rs`](https://github.com/rust-lang/rust/blob/master/src/bootstrap/src/bin/main.rs)
+1. Shell script or `make`: [`./x`](https://github.com/rust-lang/rust/blob/HEAD/x) or [`./x.ps1`](https://github.com/rust-lang/rust/blob/HEAD/x.ps1) or `make`
+2. Convenience wrapper script: [`x.py`](https://github.com/rust-lang/rust/blob/HEAD/x.py)
+3. [`src/bootstrap/bootstrap.py`](https://github.com/rust-lang/rust/blob/HEAD/src/bootstrap/bootstrap.py)
+4. [`src/bootstrap/src/bin/main.rs`](https://github.com/rust-lang/rust/blob/HEAD/src/bootstrap/src/bin/main.rs)
 
-See [src/bootstrap/README.md](https://github.com/rust-lang/rust/blob/master/src/bootstrap/README.md)
+See [src/bootstrap/README.md](https://github.com/rust-lang/rust/blob/HEAD/src/bootstrap/README.md)
 for a more specific description of the implementation details.
 
 [`Step`]: https://doc.rust-lang.org/nightly/nightly-rustc/bootstrap/core/builder/trait.Step.html
diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/what-bootstrapping-does.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/what-bootstrapping-does.md
index bfd75ebda4002..89eca0f0a1c65 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/what-bootstrapping-does.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/what-bootstrapping-does.md
@@ -12,12 +12,12 @@ only way to build a modern version of `rustc` is with a slightly less modern ver
 This is exactly how [`./x.py`] works: it downloads the current beta release of
 `rustc`, then uses it to compile the new compiler.
 
-[`./x.py`]: https://github.com/rust-lang/rust/blob/master/x.py
+[`./x.py`]: https://github.com/rust-lang/rust/blob/HEAD/x.py
 
 Note that this documentation mostly covers user-facing information. See
 [bootstrap/README.md][bootstrap-internals] to read about bootstrap internals.
 
-[bootstrap-internals]: https://github.com/rust-lang/rust/blob/master/src/bootstrap/README.md
+[bootstrap-internals]: https://github.com/rust-lang/rust/blob/HEAD/src/bootstrap/README.md
 
 ## Stages of bootstrapping
 
@@ -74,8 +74,8 @@ build the stage2 compiler.
 There are two concepts at play here: a compiler (with its set of dependencies) and its
 'target' or 'object' libraries (`std` and `rustc`). Both are staged, but in a staggered manner.
 
-[`compiler/rustc`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc
-[`src/bootstrap`]: https://github.com/rust-lang/rust/tree/master/src/bootstrap
+[`compiler/rustc`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc
+[`src/bootstrap`]: https://github.com/rust-lang/rust/tree/HEAD/src/bootstrap
 
 ### Stage 1: from current code, by an earlier compiler
 
@@ -129,7 +129,7 @@ You can always override the stage by passing `--stage N` explicitly.
 For more information about stages, [see
 below](#understanding-stages-of-bootstrap).
 
-[`./x`]: https://github.com/rust-lang/rust/blob/master/x
+[`./x`]: https://github.com/rust-lang/rust/blob/HEAD/x
 
 ## Complications of bootstrapping
 
diff --git a/src/doc/rustc-dev-guide/src/building/prerequisites.md b/src/doc/rustc-dev-guide/src/building/prerequisites.md
index 6761cabac1f14..d984cc4e391d4 100644
--- a/src/doc/rustc-dev-guide/src/building/prerequisites.md
+++ b/src/doc/rustc-dev-guide/src/building/prerequisites.md
@@ -2,7 +2,7 @@
 
 ## Dependencies
 
-See [the `rust-lang/rust` INSTALL](https://github.com/rust-lang/rust/blob/master/INSTALL.md#dependencies).
+See [the `rust-lang/rust` INSTALL](https://github.com/rust-lang/rust/blob/HEAD/INSTALL.md#dependencies).
 
 ## Hardware
 
diff --git a/src/doc/rustc-dev-guide/src/building/suggested.md b/src/doc/rustc-dev-guide/src/building/suggested.md
index 6d3590eef64a3..6d7d340e633e2 100644
--- a/src/doc/rustc-dev-guide/src/building/suggested.md
+++ b/src/doc/rustc-dev-guide/src/building/suggested.md
@@ -451,15 +451,15 @@ pkgs.mkShell {
 
 If you use Bash, Zsh, Fish or PowerShell, you can find automatically-generated shell
 completion scripts for `x.py` in
-[`src/etc/completions`](https://github.com/rust-lang/rust/tree/master/src/etc/completions).
+[`src/etc/completions`](https://github.com/rust-lang/rust/tree/HEAD/src/etc/completions).
 
 You can use `source ./src/etc/completions/x.py.<extension>` to load completions
 for your shell of choice, or `& .\src\etc\completions\x.py.ps1` for PowerShell.
 Adding this to your shell's startup script (e.g. `.bashrc`) will automatically
 load this completion.
 
-[`src/etc/rust_analyzer_settings.json`]: https://github.com/rust-lang/rust/blob/master/src/etc/rust_analyzer_settings.json
-[`src/etc/rust_analyzer_eglot.el`]: https://github.com/rust-lang/rust/blob/master/src/etc/rust_analyzer_eglot.el
-[`src/etc/rust_analyzer_helix.toml`]: https://github.com/rust-lang/rust/blob/master/src/etc/rust_analyzer_helix.toml
-[`src/etc/rust_analyzer_zed.json`]: https://github.com/rust-lang/rust/blob/master/src/etc/rust_analyzer_zed.json
-[`src/etc/pre-push.sh`]: https://github.com/rust-lang/rust/blob/master/src/etc/pre-push.sh
+[`src/etc/rust_analyzer_settings.json`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/rust_analyzer_settings.json
+[`src/etc/rust_analyzer_eglot.el`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/rust_analyzer_eglot.el
+[`src/etc/rust_analyzer_helix.toml`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/rust_analyzer_helix.toml
+[`src/etc/rust_analyzer_zed.json`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/rust_analyzer_zed.json
+[`src/etc/pre-push.sh`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/pre-push.sh
diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md
index f451447041802..1944bf53378d4 100644
--- a/src/doc/rustc-dev-guide/src/compiler-debugging.md
+++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md
@@ -158,7 +158,7 @@ error: internal compiler error: unexpected panic
 
 note: the compiler unexpectedly panicked. this is a bug.
 
-note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports
+note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/HEAD/CONTRIBUTING.md#bug-reports
 
 note: rustc 1.24.0-dev running on x86_64-unknown-linux-gnu
 
@@ -284,7 +284,7 @@ Here are some notable ones:
 
 Right below you can find elaborate explainers on a selected few.
 
-[`builtin_attrs`]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_feature/src/builtin_attrs.rs
+[`builtin_attrs`]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_feature/src/builtin_attrs.rs
 [`def_path_str`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.def_path_str
 [`inferred_outlives_of`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.inferred_outlives_of
 [`item_bounds`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.item_bounds
diff --git a/src/doc/rustc-dev-guide/src/compiler-src.md b/src/doc/rustc-dev-guide/src/compiler-src.md
index 27b40f1fe0178..9b19c6fa9b6c7 100644
--- a/src/doc/rustc-dev-guide/src/compiler-src.md
+++ b/src/doc/rustc-dev-guide/src/compiler-src.md
@@ -32,23 +32,23 @@ The repository consists of three main directories:
 - [`src/`] contains the source code for [`rustdoc`], [`clippy`], [`cargo`], the build system,
   language docs, etc.
 
-[`alloc`]: https://github.com/rust-lang/rust/tree/master/library/alloc
+[`alloc`]: https://github.com/rust-lang/rust/tree/HEAD/library/alloc
 [`backtrace`]: https://github.com/rust-lang/backtrace-rs/
 [`cargo`]: https://github.com/rust-lang/cargo
-[`clippy`]: https://github.com/rust-lang/rust/tree/master/src/tools/clippy
-[`compiler/`]: https://github.com/rust-lang/rust/tree/master/compiler
-[`core`]: https://github.com/rust-lang/rust/tree/master/library/core
-[`etc`]: https://github.com/rust-lang/rust/tree/master/src/etc
-[`lang_start`]: https://github.com/rust-lang/rust/blob/master/library/std/src/rt.rs
-[`library/`]: https://github.com/rust-lang/rust/tree/master/library
-[`proc_macro`]: https://github.com/rust-lang/rust/tree/master/library/proc_macro
-[`rtstartup`]: https://github.com/rust-lang/rust/tree/master/library/rtstartup
+[`clippy`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/clippy
+[`compiler/`]: https://github.com/rust-lang/rust/tree/HEAD/compiler
+[`core`]: https://github.com/rust-lang/rust/tree/HEAD/library/core
+[`etc`]: https://github.com/rust-lang/rust/tree/HEAD/src/etc
+[`lang_start`]: https://github.com/rust-lang/rust/blob/HEAD/library/std/src/rt.rs
+[`library/`]: https://github.com/rust-lang/rust/tree/HEAD/library
+[`proc_macro`]: https://github.com/rust-lang/rust/tree/HEAD/library/proc_macro
+[`rtstartup`]: https://github.com/rust-lang/rust/tree/HEAD/library/rtstartup
 [`rust-lang/rust`]: https://github.com/rust-lang/rust
-[`rustdoc`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
-[`src/`]: https://github.com/rust-lang/rust/tree/master/src
-[`std`]: https://github.com/rust-lang/rust/tree/master/library/std
-[`test`]: https://github.com/rust-lang/rust/tree/master/library/test
-[`tests/`]: https://github.com/rust-lang/rust/tree/master/tests
+[`rustdoc`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc
+[`src/`]: https://github.com/rust-lang/rust/tree/HEAD/src
+[`std`]: https://github.com/rust-lang/rust/tree/HEAD/library/std
+[`test`]: https://github.com/rust-lang/rust/tree/HEAD/library/test
+[`tests/`]: https://github.com/rust-lang/rust/tree/HEAD/tests
 
 ## Compiler
 
@@ -99,9 +99,9 @@ compiler can interface with it.
 Most of this book is about the compiler, so we won't have any further
 explanation of these crates here.
 
-[`compiler/rustc_llvm`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_llvm
-[`src/llvm-project`]: https://github.com/rust-lang/rust/tree/master/src/
-[`Cargo.toml`]: https://github.com/rust-lang/rust/blob/master/Cargo.toml
+[`compiler/rustc_llvm`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_llvm
+[`src/llvm-project`]: https://github.com/rust-lang/rust/tree/HEAD/src/
+[`Cargo.toml`]: https://github.com/rust-lang/rust/blob/HEAD/Cargo.toml
 
 ### Big picture
 
@@ -160,10 +160,10 @@ You can read more about [`rustdoc`] in [this chapter][rustdoc-chapter].
 
 [`librustdoc`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/index.html
 [`rustdoc::main`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/fn.main.html
-[`src/tools/rustdoc-js`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-js
-[`src/tools/rustdoc-themes`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-themes
-[`src/tools/rustdoc`]:  https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
-[`src/rustdoc-json-types`]: https://github.com/rust-lang/rust/tree/master/src/rustdoc-json-types
+[`src/tools/rustdoc-js`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc-js
+[`src/tools/rustdoc-themes`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc-themes
+[`src/tools/rustdoc`]:  https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc
+[`src/rustdoc-json-types`]: https://github.com/rust-lang/rust/tree/HEAD/src/rustdoc-json-types
 [rustdoc-chapter]: ./rustdoc.md
 
 ## Tests
@@ -173,7 +173,7 @@ about the test suite [in this chapter][testsch].
 
 The test harness is in [`src/tools/compiletest/`][`compiletest/`].
 
-[`tests/`]: https://github.com/rust-lang/rust/tree/master/tests
+[`tests/`]: https://github.com/rust-lang/rust/tree/HEAD/tests
 [testsch]: ./tests/intro.md
 
 ## Build System
@@ -186,10 +186,10 @@ One of the primary tools is [`src/bootstrap/`]. You can read more about
 bootstrapping [in this chapter][bootstch]. The process may also use other tools
 from [`src/tools/`], such as [`tidy/`] or [`compiletest/`].
 
-[`compiletest/`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest
-[`src/bootstrap/`]: https://github.com/rust-lang/rust/tree/master/src/bootstrap
-[`src/tools/`]: https://github.com/rust-lang/rust/tree/master/src/tools
-[`tidy/`]: https://github.com/rust-lang/rust/tree/master/src/tools/tidy
+[`compiletest/`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest
+[`src/bootstrap/`]: https://github.com/rust-lang/rust/tree/HEAD/src/bootstrap
+[`src/tools/`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools
+[`tidy/`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/tidy
 [bootstch]: ./building/bootstrapping/intro.md
 
 ## Standard library
@@ -213,6 +213,6 @@ These include:
 - [`src/etc`]: Miscellaneous utilities.
 - And more...
 
-[`src/ci`]: https://github.com/rust-lang/rust/tree/master/src/ci
-[`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
-[`src/etc`]: https://github.com/rust-lang/rust/tree/master/src/etc
+[`src/ci`]: https://github.com/rust-lang/rust/tree/HEAD/src/ci
+[`src/doc`]: https://github.com/rust-lang/rust/tree/HEAD/src/doc
+[`src/etc`]: https://github.com/rust-lang/rust/tree/HEAD/src/etc
diff --git a/src/doc/rustc-dev-guide/src/compiler-team.md b/src/doc/rustc-dev-guide/src/compiler-team.md
index 9556811e842c2..dfc1e7eedf622 100644
--- a/src/doc/rustc-dev-guide/src/compiler-team.md
+++ b/src/doc/rustc-dev-guide/src/compiler-team.md
@@ -29,7 +29,7 @@ check out [triagebot.toml's assign section][map].
 It contains a listing of the various parts of the compiler and a list of people
 who are reviewers of each part.
 
-[map]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
+[map]: https://github.com/rust-lang/rust/blob/HEAD/triagebot.toml
 
 ## Rust compiler meeting
 
diff --git a/src/doc/rustc-dev-guide/src/const-eval/interpret.md b/src/doc/rustc-dev-guide/src/const-eval/interpret.md
index 08382b12ff00a..8487b2bed43ab 100644
--- a/src/doc/rustc-dev-guide/src/const-eval/interpret.md
+++ b/src/doc/rustc-dev-guide/src/const-eval/interpret.md
@@ -106,7 +106,7 @@ the interpreter, but just use the cached result.
 ## Datastructures
 
 The interpreter's outside-facing datastructures can be found in
-[rustc_middle/src/mir/interpret](https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/mir/interpret).
+[rustc_middle/src/mir/interpret](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_middle/src/mir/interpret).
 This is mainly the error enum and the [`ConstValue`] and [`Scalar`] types. A
 `ConstValue` can be either `Scalar` (a single `Scalar`, i.e., integer or thin
 pointer), `Slice` (to represent byte slices and strings, as needed for pattern
@@ -217,7 +217,7 @@ function with no arguments, except that constants do not allow local (named)
 variables at the time of writing this guide.
 
 A stack frame is defined by the `Frame` type in
-[rustc_const_eval/src/interpret/eval_context.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/eval_context.rs)
+[rustc_const_eval/src/interpret/eval_context.rs](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/eval_context.rs)
 and contains all the local
 variables memory (`None` at the start of evaluation). Each frame refers to the
 evaluation of either the root constant or subsequent calls to `const fn`. The
@@ -229,7 +229,7 @@ The frames are just a `Vec<Frame>`, there's no way to actually refer to a
 memory that can be referred to are `Allocation`s.
 
 The interpreter now calls the `step` method (in
-[rustc_const_eval/src/interpret/step.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/step.rs)
+[rustc_const_eval/src/interpret/step.rs](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_const_eval/src/interpret/step.rs)
 ) until it either returns an error or has no further statements to execute. Each
 statement will now initialize or modify the locals or the virtual memory
 referred to by a local. This might require evaluating other constants or
diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 44d630080bbfa..366c3e45a769f 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -145,7 +145,7 @@ when contributing to Rust under [the git section](./git.md).
 [about-pull-requests]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests
 [development-models]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/getting-started/about-collaborative-development-models#fork-and-pull-model
 [t-compiler]: https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler
-[triagebot]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
+[triagebot]: https://github.com/rust-lang/rust/blob/HEAD/triagebot.toml
 
 ### Keeping your branch up-to-date
 
@@ -357,8 +357,8 @@ is located in [`src/doc`] in the tree, and standard API documentation is generat
 from the source code itself (e.g. [`library/std/src/lib.rs`][std-root]). Documentation pull requests
 function in the same way as other pull requests.
 
-[`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
-[std-root]: https://github.com/rust-lang/rust/blob/master/library/std/src/lib.rs#L1
+[`src/doc`]: https://github.com/rust-lang/rust/tree/HEAD/src/doc
+[std-root]: https://github.com/rust-lang/rust/blob/HEAD/library/std/src/lib.rs#L1
 
 To find documentation-related issues, use the [A-docs label].
 
diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index 5fb7eeee8e3b0..fb291aa777ae7 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -167,7 +167,7 @@ before the PR is merged. They are also not allowed to be broken on master in
 the week leading up to the beta cut.
 
 [git submodules]: https://git-scm.com/book/en/v2/Git-Tools-Submodules
-[`.gitmodules`]: https://github.com/rust-lang/rust/blob/master/.gitmodules
+[`.gitmodules`]: https://github.com/rust-lang/rust/blob/HEAD/.gitmodules
 [The Rust Reference]: https://github.com/rust-lang/reference/
 [toolstate website]: https://rust-lang-nursery.github.io/rust-toolstate/
 [Toolstate chapter]: https://forge.rust-lang.org/infra/toolstate.html
diff --git a/src/doc/rustc-dev-guide/src/getting-started.md b/src/doc/rustc-dev-guide/src/getting-started.md
index 685b97329bb0c..857e8ff51b03d 100644
--- a/src/doc/rustc-dev-guide/src/getting-started.md
+++ b/src/doc/rustc-dev-guide/src/getting-started.md
@@ -59,7 +59,7 @@ you could run `git shortlog -n 1.68.2.. compiler/rustc_resolve/`. Ignore any com
 "Rollup merge" or commits by `@bors` (see [CI contribution procedures](./contributing.md#ci) for
 more information about these commits).
 
-[map]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
+[map]: https://github.com/rust-lang/rust/blob/HEAD/triagebot.toml
 
 ### Etiquette
 
diff --git a/src/doc/rustc-dev-guide/src/git.md b/src/doc/rustc-dev-guide/src/git.md
index 8f0511a4548af..56f1f01f26dbf 100644
--- a/src/doc/rustc-dev-guide/src/git.md
+++ b/src/doc/rustc-dev-guide/src/git.md
@@ -638,7 +638,7 @@ checkouts for you.
 
 Some commits contain large reformatting changes that don't otherwise change functionality. They can
 be instructed to be ignored by `git blame` through
-[`.git-blame-ignore-revs`](https://github.com/rust-lang/rust/blob/master/.git-blame-ignore-revs):
+[`.git-blame-ignore-revs`](https://github.com/rust-lang/rust/blob/HEAD/.git-blame-ignore-revs):
 
 1. Configure `git blame` to use `.git-blame-ignore-revs` as the list of commits to ignore: `git
    config blame.ignorerevsfile .git-blame-ignore-revs`
diff --git a/src/doc/rustc-dev-guide/src/guides/editions.md b/src/doc/rustc-dev-guide/src/guides/editions.md
index b65fbb13cd185..107d5e737e836 100644
--- a/src/doc/rustc-dev-guide/src/guides/editions.md
+++ b/src/doc/rustc-dev-guide/src/guides/editions.md
@@ -375,8 +375,8 @@ After the edition team has given the go-ahead, the process for stabilizing an ed
 - Update [`LATEST_STABLE_EDITION`].
 - Update [`Edition::is_stable`].
 - Hunt and find any document that refers to edition by number, and update it:
-    - [`--edition` flag](https://github.com/rust-lang/rust/blob/master/src/doc/rustc/src/command-line-arguments.md#--edition-specify-the-edition-to-use)
-    - [Rustdoc attributes](https://github.com/rust-lang/rust/blob/master/src/doc/rustdoc/src/write-documentation/documentation-tests.md#attributes)
+    - [`--edition` flag](https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustc/src/command-line-arguments.md#--edition-specify-the-edition-to-use)
+    - [Rustdoc attributes](https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustdoc/src/write-documentation/documentation-tests.md#attributes)
 - Clean up any tests that use the `//@ edition` header to remove the `-Zunstable-options` flag to ensure they are indeed stable. Note: Ideally this should be automated, see [#133582].
 - Bless any tests that change.
 - Update `lint-docs` to default to the new edition.
diff --git a/src/doc/rustc-dev-guide/src/incrcomp-debugging.md b/src/doc/rustc-dev-guide/src/incrcomp-debugging.md
index a548215cf0cee..8207b81665aa7 100644
--- a/src/doc/rustc-dev-guide/src/incrcomp-debugging.md
+++ b/src/doc/rustc-dev-guide/src/incrcomp-debugging.md
@@ -7,7 +7,7 @@ simplest mechanisms are the `#[rustc_if_this_changed]` and
 `#[rustc_then_this_would_need]` annotations. These are used in [ui] tests to test
 whether the expected set of paths exist in the dependency graph.
 
-[`tests/ui/dep-graph/dep-graph-caller-callee.rs`]: https://github.com/rust-lang/rust/blob/master/tests/ui/dep-graph/dep-graph-caller-callee.rs
+[`tests/ui/dep-graph/dep-graph-caller-callee.rs`]: https://github.com/rust-lang/rust/blob/HEAD/tests/ui/dep-graph/dep-graph-caller-callee.rs
 [ui]: tests/ui.html
 
 As an example, see [`tests/ui/dep-graph/dep-graph-caller-callee.rs`], or the
diff --git a/src/doc/rustc-dev-guide/src/licenses.md b/src/doc/rustc-dev-guide/src/licenses.md
index 1d5158a9c6d63..c4fc59d27cb16 100644
--- a/src/doc/rustc-dev-guide/src/licenses.md
+++ b/src/doc/rustc-dev-guide/src/licenses.md
@@ -1,8 +1,8 @@
 # `rust-lang/rust` Licenses
 
-The `rustc` compiler source and standard library are dual licensed under the [Apache License v2.0](https://github.com/rust-lang/rust/blob/master/LICENSE-APACHE) and the [MIT License](https://github.com/rust-lang/rust/blob/master/LICENSE-MIT) unless otherwise specified.
+The `rustc` compiler source and standard library are dual licensed under the [Apache License v2.0](https://github.com/rust-lang/rust/blob/HEAD/LICENSE-APACHE) and the [MIT License](https://github.com/rust-lang/rust/blob/HEAD/LICENSE-MIT) unless otherwise specified.
 
-Detailed licensing information is available in the [COPYRIGHT document](https://github.com/rust-lang/rust/blob/master/COPYRIGHT) of the `rust-lang/rust` repository.
+Detailed licensing information is available in the [COPYRIGHT document](https://github.com/rust-lang/rust/blob/HEAD/COPYRIGHT) of the `rust-lang/rust` repository.
 
 ## Guidelines for reviewers
 
diff --git a/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
index 288b90f33c3d2..30a1c5ebc7ef4 100644
--- a/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
+++ b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
@@ -130,8 +130,8 @@ and `mir-opt` tests can be refreshed by running:
 ./x test tests/mir-opt --bless
 ```
 
-[`tests/mir-opt/coverage/instrument_coverage.rs`]: https://github.com/rust-lang/rust/blob/master/tests/mir-opt/coverage/instrument_coverage.rs
-[`tests/coverage`]: https://github.com/rust-lang/rust/tree/master/tests/coverage
-[`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/master/src/tools/coverage-dump
-[`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/master/tests/coverage-run-rustdoc
-[`tests/codegen-llvm/instrument-coverage/testprog.rs`]: https://github.com/rust-lang/rust/blob/master/tests/mir-opt/coverage/instrument_coverage.rs
+[`tests/mir-opt/coverage/instrument_coverage.rs`]: https://github.com/rust-lang/rust/blob/HEAD/tests/mir-opt/coverage/instrument_coverage.rs
+[`tests/coverage`]: https://github.com/rust-lang/rust/tree/HEAD/tests/coverage
+[`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/coverage-dump
+[`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/HEAD/tests/coverage-run-rustdoc
+[`tests/codegen-llvm/instrument-coverage/testprog.rs`]: https://github.com/rust-lang/rust/blob/HEAD/tests/mir-opt/coverage/instrument_coverage.rs
diff --git a/src/doc/rustc-dev-guide/src/macro-expansion.md b/src/doc/rustc-dev-guide/src/macro-expansion.md
index 96f12b764169e..f9ab946245b0c 100644
--- a/src/doc/rustc-dev-guide/src/macro-expansion.md
+++ b/src/doc/rustc-dev-guide/src/macro-expansion.md
@@ -226,7 +226,7 @@ a macro author may want to introduce a new name to the context where the macro
 was called. Alternately, the macro author may be defining a variable for use
 only within the macro (i.e. it should not be visible outside the macro).
 
-[code_dir]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_expand/src/mbe
+[code_dir]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_expand/src/mbe
 [code_mp]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_parser
 [code_mr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_rules
 [code_parse_int]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_parser/struct.TtParser.html#method.parse_tt
diff --git a/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md b/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md
index 4da612c83f0fc..93e21e2b227fc 100644
--- a/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md
+++ b/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md
@@ -188,6 +188,6 @@ known to be uninitialized) to run these checks.
 
 [RFC 320]: https://rust-lang.github.io/rfcs/0320-nonzeroing-dynamic-drop.html
 [reference-drop]: https://doc.rust-lang.org/reference/destructors.html
-[drops]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
-[drops-shim]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_transform/src/shim.rs
-[drops-transform]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_transform/src/elaborate_drops.rs
+[drops]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
+[drops-shim]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/shim.rs
+[drops-transform]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/elaborate_drops.rs
diff --git a/src/doc/rustc-dev-guide/src/mir/optimizations.md b/src/doc/rustc-dev-guide/src/mir/optimizations.md
index 93eeb9a372f7c..964fa063a680f 100644
--- a/src/doc/rustc-dev-guide/src/mir/optimizations.md
+++ b/src/doc/rustc-dev-guide/src/mir/optimizations.md
@@ -70,8 +70,8 @@ optimizes it, and returns the improved MIR.
 If you have any questions along the way, feel free to ask in
 `#t-compiler/wg-mir-opt` on Zulip.
 
-[mir-opt-test-readme]: https://github.com/rust-lang/rust/blob/master/tests/mir-opt/README.md
-[`compiler/rustc_mir_transform/src`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_mir_transform/src
+[mir-opt-test-readme]: https://github.com/rust-lang/rust/blob/HEAD/tests/mir-opt/README.md
+[`compiler/rustc_mir_transform/src`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_mir_transform/src
 [`remove_storage_markers`]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/remove_storage_markers.rs
 [`run_optimization_passes()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/fn.run_optimization_passes.html
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/about.md b/src/doc/rustc-dev-guide/src/notification-groups/about.md
index d75891ecf7b29..c649b930fe9ff 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/about.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/about.md
@@ -104,4 +104,4 @@ triage.**
 
 [rustbot]: https://github.com/rust-lang/triagebot/
 [`ping`]: https://forge.rust-lang.org/triagebot/pinging.html
-[`triagebot.toml`]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
+[`triagebot.toml`]: https://github.com/rust-lang/rust/blob/HEAD/triagebot.toml
diff --git a/src/doc/rustc-dev-guide/src/overview.md b/src/doc/rustc-dev-guide/src/overview.md
index 378d8c4453f89..f83b5b2e181c8 100644
--- a/src/doc/rustc-dev-guide/src/overview.md
+++ b/src/doc/rustc-dev-guide/src/overview.md
@@ -63,10 +63,10 @@ Parsing is organized by semantic construct. Separate
 directory. The source file name follows the construct name. For example, the
 following files are found in the `parser`:
 
-- [`expr.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_parse/src/parser/expr.rs)
-- [`pat.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_parse/src/parser/pat.rs)
-- [`ty.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_parse/src/parser/ty.rs)
-- [`stmt.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_parse/src/parser/stmt.rs)
+- [`expr.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_parse/src/parser/expr.rs)
+- [`pat.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_parse/src/parser/pat.rs)
+- [`ty.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_parse/src/parser/ty.rs)
+- [`stmt.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_parse/src/parser/stmt.rs)
 
 This naming scheme is used across many compiler stages. You will find either a
 file or directory with the same name across the parsing, lowering, type
@@ -164,7 +164,7 @@ the final binary.
 [parse_mod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html#method.parse_mod
 [parse_nonterminal]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html#method.parse_nonterminal
 [parser]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
-[rustc_parse_parser_dir]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_parse/src/parser
+[rustc_parse_parser_dir]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_parse/src/parser
 [String interning]: https://en.wikipedia.org/wiki/String_interning
 [thir]: ./thir.md
 
diff --git a/src/doc/rustc-dev-guide/src/panic-implementation.md b/src/doc/rustc-dev-guide/src/panic-implementation.md
index dba3f2146d23d..ea71abff19998 100644
--- a/src/doc/rustc-dev-guide/src/panic-implementation.md
+++ b/src/doc/rustc-dev-guide/src/panic-implementation.md
@@ -110,4 +110,4 @@ In particular, in std's [runtime service],
 the call to the user-provided `main` function is wrapped in `catch_unwind`.
 
 
-[runtime service]: https://github.com/rust-lang/rust/blob/master/library/std/src/rt.rs
+[runtime service]: https://github.com/rust-lang/rust/blob/HEAD/library/std/src/rt.rs
diff --git a/src/doc/rustc-dev-guide/src/profile-guided-optimization.md b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
index 4e3dadd406ec0..f8a07813a10eb 100644
--- a/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
+++ b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
@@ -129,8 +129,8 @@ in [run-make tests][rmake-tests] (the relevant tests have `pgo` in their name).
 There is also a [codegen test][codegen-test] that checks that some expected
 instrumentation artifacts show up in LLVM IR.
 
-[rmake-tests]: https://github.com/rust-lang/rust/tree/master/tests/run-make
-[codegen-test]: https://github.com/rust-lang/rust/blob/master/tests/codegen-llvm/pgo-instrumentation.rs
+[rmake-tests]: https://github.com/rust-lang/rust/tree/HEAD/tests/run-make
+[codegen-test]: https://github.com/rust-lang/rust/blob/HEAD/tests/codegen-llvm/pgo-instrumentation.rs
 
 ## Additional information
 
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals.md b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
index 4affbafe4777a..55b08e8893c0b 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
@@ -3,7 +3,7 @@
 This page describes [`rustdoc`]'s passes and modes. For an overview of `rustdoc`,
 see the ["Rustdoc overview" chapter](./rustdoc.md).
 
-[`rustdoc`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
+[`rustdoc`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc
 
 ## From Crate to Clean
 
@@ -72,8 +72,8 @@ which describe the publicly-documentable items in the target crate.
 [`Attributes`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/clean/types/struct.Attributes.html
 [`clean_doc_module`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/clean/fn.clean_doc_module.html
 [`clean::types::Crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/clean/types/struct.Crate.html
-[`clean/mod.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/clean/mod.rs
-[`core.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/core.rs
+[`clean/mod.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/clean/mod.rs
+[`core.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/core.rs
 [`Item`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/clean/types/struct.Item.html
 [`run_global_ctxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/core/fn.run_global_ctxt.html
 [`rustc_hir::Crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/struct.Crate.html
@@ -150,7 +150,7 @@ There is also a [`stripper`] module in `librustdoc/passes`, but it is a
 collection of utility functions for the `strip-*` passes and is not a pass
 itself.
 
-[`librustdoc/passes`]: https://github.com/rust-lang/rust/tree/master/src/librustdoc/passes
+[`librustdoc/passes`]: https://github.com/rust-lang/rust/tree/HEAD/src/librustdoc/passes
 [`stripper`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/passes/stripper/index.html
 
 ## From Clean To HTML
@@ -193,13 +193,13 @@ the test-runner code can find all the `doctest`s in the crate.
 
 [`find_codes`]: https://doc.rust-lang.org/nightly/nightly-rustc/src/rustdoc/html/markdown.rs.html#749-818
 [`formats::renderer::run_format`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/formats/renderer/fn.run_format.html
-[`html/format.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/format.rs
-[`html/layout.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/layout.rs
-[`html/markdown.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/markdown.rs
-[`html/render/mod.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/mod.rs
-[`html/render/print_item.rs`]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/print_item.rs
-[`librustdoc/formats`]: https://github.com/rust-lang/rust/tree/master/src/librustdoc/formats
-[`librustdoc/html`]: https://github.com/rust-lang/rust/tree/master/src/librustdoc/html
+[`html/format.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/format.rs
+[`html/layout.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/layout.rs
+[`html/markdown.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/markdown.rs
+[`html/render/mod.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/render/mod.rs
+[`html/render/print_item.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/render/print_item.rs
+[`librustdoc/formats`]: https://github.com/rust-lang/rust/tree/HEAD/src/librustdoc/formats
+[`librustdoc/html`]: https://github.com/rust-lang/rust/tree/HEAD/src/librustdoc/html
 [`print_item`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/html/render/print_item/fn.print_item.html
 [Askama]: https://docs.rs/askama/latest/askama/
 
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-gui-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-gui-test-suite.md
index e155f960e3d6a..419f03d020a83 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-gui-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-gui-test-suite.md
@@ -10,5 +10,5 @@ These use a NodeJS-based tool called [`browser-UI-test`] that uses [puppeteer] t
 [Rustdoc test suites]: ../tests/compiletest.md#rustdoc-test-suites
 [`browser-UI-test`]: https://github.com/GuillaumeGomez/browser-UI-test/
 [puppeteer]: https://pptr.dev/
-[rustdoc-gui-readme]: https://github.com/rust-lang/rust/blob/master/tests/rustdoc-gui/README.md
+[rustdoc-gui-readme]: https://github.com/rust-lang/rust/blob/HEAD/tests/rustdoc-gui/README.md
 [goml-script]: https://github.com/GuillaumeGomez/browser-UI-test/blob/master/goml-script.md
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index 10e9452eda3f1..e19a8204ab41a 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -73,11 +73,11 @@ To use the `@ is` with a `<path>` of `$.index[?(@.docs == "foo")].some.field` an
     it needs to be a JSON string value.
 
 [json output]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html#json-output
-[jsondocck]: https://github.com/rust-lang/rust/tree/master/src/tools/jsondocck
-[jsondoclint]: https://github.com/rust-lang/rust/tree/master/src/tools/jsondoclint
+[jsondocck]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/jsondocck
+[jsondoclint]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/jsondoclint
 [aux-build]: ../tests/compiletest.md#building-auxiliary-crates
 [`Id`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc_json_types/struct.Id.html
 [document private items]: https://doc.rust-lang.org/nightly/rustdoc/command-line-arguments.html#--document-private-items-show-items-that-are-not-public
-[`directive.rs`]: https://github.com/rust-lang/rust/blob/master/src/tools/jsondocck/src/directive.rs
+[`directive.rs`]: https://github.com/rust-lang/rust/blob/HEAD/src/tools/jsondocck/src/directive.rs
 [shlex]: https://docs.rs/shlex/1.3.0/shlex/index.html
 [JSONPath]: https://www.rfc-editor.org/rfc/rfc9535.html
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
index 3ec5ebd799ef2..9516968df803e 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
@@ -14,7 +14,7 @@ Internally, [`compiletest`] invokes the supplementary checker script [`htmldocck
 
 [Rustdoc test suites]: ../tests/compiletest.md#rustdoc-test-suites
 [`compiletest`]: ../tests/compiletest.md
-[`htmldocck.py`]: https://github.com/rust-lang/rust/blob/master/src/etc/htmldocck.py
+[`htmldocck.py`]: https://github.com/rust-lang/rust/blob/HEAD/src/etc/htmldocck.py
 
 ## HtmlDocCk Directives
 
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/search.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/search.md
index 9cf59ea0c3812..e88d2703e3a23 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/search.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/search.md
@@ -467,7 +467,7 @@ want the libs team to be able to add new items without causing unrelated
 tests to fail, but standalone tests will use it more often.
 
 The `ResultsTable` and `ParsedQuery` types are specified in
-[`rustdoc.d.ts`](https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/static/js/rustdoc.d.ts).
+[`rustdoc.d.ts`](https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/static/js/rustdoc.d.ts).
 
 For example, imagine we needed to fix a bug where a function named
 `constructor` couldn't be found. To do this, write two files:
diff --git a/src/doc/rustc-dev-guide/src/rustdoc.md b/src/doc/rustc-dev-guide/src/rustdoc.md
index b021f58ed73b9..7901e951112c9 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc.md
@@ -19,7 +19,7 @@ and [queries] are discussed in the linked chapters.
 
 [HIR]: ./hir.md
 [queries]: ./query.md
-[rd]: https://github.com/rust-lang/rust/tree/master/src/librustdoc
+[rd]: https://github.com/rust-lang/rust/tree/HEAD/src/librustdoc
 
 `librustdoc` performs two major steps after that to render a set of
 documentation:
@@ -35,7 +35,7 @@ lots of details, but that's the high-level overview.
 using the project in [`src/tools/rustdoc`][bin]. Note that literally all that
 does is call the `main()` that's in this crate's `lib.rs`, though.)
 
-[bin]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
+[bin]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/rustdoc
 
 ## Cheat sheet
 
diff --git a/src/doc/rustc-dev-guide/src/sanitizers.md b/src/doc/rustc-dev-guide/src/sanitizers.md
index 34c78d4d952d5..fd91fdb2504d8 100644
--- a/src/doc/rustc-dev-guide/src/sanitizers.md
+++ b/src/doc/rustc-dev-guide/src/sanitizers.md
@@ -85,8 +85,8 @@ sanitizer. When sanitizer is unsupported on given target, sanitizers tests will
 be ignored. This behaviour is controlled by compiletest `needs-sanitizer-*`
 directives.
 
-[test-cg]: https://github.com/rust-lang/rust/tree/master/tests/codegen-llvm
-[test-ui]: https://github.com/rust-lang/rust/tree/master/tests/ui/sanitizer
+[test-cg]: https://github.com/rust-lang/rust/tree/HEAD/tests/codegen-llvm
+[test-ui]: https://github.com/rust-lang/rust/tree/HEAD/tests/ui/sanitizer
 
 ## Enabling sanitizer on a new target
 
diff --git a/src/doc/rustc-dev-guide/src/serialization.md b/src/doc/rustc-dev-guide/src/serialization.md
index 702d3cfa6d5ee..a6c2ee17a6678 100644
--- a/src/doc/rustc-dev-guide/src/serialization.md
+++ b/src/doc/rustc-dev-guide/src/serialization.md
@@ -137,11 +137,11 @@ and `Encodable`.
 
 [`MetadataDecodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_macros/derive.MetadataDecodable.html
 [`MetadataEncodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_macros/derive.MetadataEncodable.html
-[`rustc_macros`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_macros
+[`rustc_macros`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_macros
 [`rustc_metadata::rmeta::`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/index.html
 [`rustc_metadata::rmeta::decoder::DecodeContext`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/decoder/struct.DecodeContext.html
 [`rustc_metadata::rmeta::encoder::EncodeContext`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/encoder/struct.EncodeContext.html
-[`rustc_middle`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_middle
+[`rustc_middle`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_middle
 
 ## Shorthands
 
diff --git a/src/doc/rustc-dev-guide/src/solve/opaque-types.md b/src/doc/rustc-dev-guide/src/solve/opaque-types.md
index 8880962d621f0..ac038e354f53f 100644
--- a/src/doc/rustc-dev-guide/src/solve/opaque-types.md
+++ b/src/doc/rustc-dev-guide/src/solve/opaque-types.md
@@ -56,7 +56,7 @@ Finally, we check whether the item bounds of the opaque hold for the expected ty
 [source][item-bounds-ck].
 
 [norm]: https://github.com/rust-lang/rust/blob/384d26fc7e3bdd7687cc17b2662b091f6017ec2a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs#L13
-[coherence-example]: https://github.com/rust-lang/rust/blob/master/tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.rs
+[coherence-example]: https://github.com/rust-lang/rust/blob/HEAD/tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.rs
 [placeholder-ck]: https://github.com/rust-lang/rust/blob/384d26fc7e3bdd7687cc17b2662b091f6017ec2a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs#L33
 [check-storage]: https://github.com/rust-lang/rust/blob/384d26fc7e3bdd7687cc17b2662b091f6017ec2a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs#L51-L52
 [eq-prev]: https://github.com/rust-lang/rust/blob/384d26fc7e3bdd7687cc17b2662b091f6017ec2a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs#L51-L59
diff --git a/src/doc/rustc-dev-guide/src/solve/significant-changes.md b/src/doc/rustc-dev-guide/src/solve/significant-changes.md
index eac8f0318fb19..cedd9887d2771 100644
--- a/src/doc/rustc-dev-guide/src/solve/significant-changes.md
+++ b/src/doc/rustc-dev-guide/src/solve/significant-changes.md
@@ -60,7 +60,7 @@ As the new implementation has to be able to eagerly handle nested goals for
 candidate selection, always doing so reduces complexity. It may also enable
 us to merge more candidates in the future.
 
-[eval-nested]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_trait_selection/src/traits/select/mod.rs#L1271-L1277
+[eval-nested]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_trait_selection/src/traits/select/mod.rs#L1271-L1277
 [fulfill-nested]: https://github.com/rust-lang/rust/blob/df8ac8f1d74cffb96a93ae702d16e224f5b9ee8c/compiler/rustc_trait_selection/src/traits/fulfill.rs#L708-L712
 
 ### Nested goals are evaluated until reaching a fixpoint
diff --git a/src/doc/rustc-dev-guide/src/stabilization_guide.md b/src/doc/rustc-dev-guide/src/stabilization_guide.md
index 7b9e1eb5629b4..c4b265ba034f7 100644
--- a/src/doc/rustc-dev-guide/src/stabilization_guide.md
+++ b/src/doc/rustc-dev-guide/src/stabilization_guide.md
@@ -104,17 +104,17 @@ if something { /* XXX */ }
 
 [rust-lang/rust#32409]: https://github.com/rust-lang/rust/issues/32409
 [std-guide-stabilization]: https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html
-[src-version]: https://github.com/rust-lang/rust/blob/master/src/version
+[src-version]: https://github.com/rust-lang/rust/blob/HEAD/src/version
 [forge-versions]: https://forge.rust-lang.org/#current-release-versions
 [forge-release-process]: https://forge.rust-lang.org/release/process.html
 [`compiler/rustc_feature`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_feature/index.html
-[`compiler/rustc_feature/src/accepted.rs`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_feature/src/accepted.rs
-[`compiler/rustc_feature/src/unstable.rs`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_feature/src/unstable.rs
+[`compiler/rustc_feature/src/accepted.rs`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_feature/src/accepted.rs
+[`compiler/rustc_feature/src/unstable.rs`]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_feature/src/unstable.rs
 [The Reference]: https://github.com/rust-lang/reference
 [The Book]: https://github.com/rust-lang/book
 [Rust by Example]: https://github.com/rust-lang/rust-by-example
 [`Unstable Book`]: https://doc.rust-lang.org/unstable-book/index.html
-[`src/doc/unstable-book`]: https://github.com/rust-lang/rust/tree/master/src/doc/unstable-book
+[`src/doc/unstable-book`]: https://github.com/rust-lang/rust/tree/HEAD/src/doc/unstable-book
 
 ## Team nominations
 
diff --git a/src/doc/rustc-dev-guide/src/test-implementation.md b/src/doc/rustc-dev-guide/src/test-implementation.md
index f09d73631998f..14a66e002dba9 100644
--- a/src/doc/rustc-dev-guide/src/test-implementation.md
+++ b/src/doc/rustc-dev-guide/src/test-implementation.md
@@ -157,7 +157,7 @@ $ rustc my_mod.rs -Z unpretty=hir
 [`TestDesc`]: https://doc.rust-lang.org/test/struct.TestDesc.html
 [ast]: ./ast-validation.md
 [Ident]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Ident.html
-[rustc_ast]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_ast
+[rustc_ast]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_ast
 [Symbol]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Symbol.html
 [test]: https://doc.rust-lang.org/test/index.html
 [tdaf]: https://doc.rust-lang.org/test/struct.TestDescAndFn.html
diff --git a/src/doc/rustc-dev-guide/src/tests/adding.md b/src/doc/rustc-dev-guide/src/tests/adding.md
index 46b8a1e4cf4b4..b02d8a0f02077 100644
--- a/src/doc/rustc-dev-guide/src/tests/adding.md
+++ b/src/doc/rustc-dev-guide/src/tests/adding.md
@@ -39,7 +39,7 @@ to work with that stand the test of time (i.e. if a test fails or need to be
 modified several years later, how can we make it easier for them?).
 
 [compiletest]: compiletest.md
-[`tests/ui`]: https://github.com/rust-lang/rust/tree/master/tests/ui/
+[`tests/ui`]: https://github.com/rust-lang/rust/tree/HEAD/tests/ui/
 
 ## UI test walkthrough
 
diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index 6c0b5c2e84554..a36f8ab0a1a72 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -333,7 +333,7 @@ platform.
 These builders are running on a special pool of builders set up and maintained
 for us by GitHub.
 
-[Docker container]: https://github.com/rust-lang/rust/tree/master/src/ci/docker
+[Docker container]: https://github.com/rust-lang/rust/tree/HEAD/src/ci/docker
 
 ## Caching
 
@@ -460,11 +460,11 @@ this:
 5. All of the build settings are listed on the line with the text, `build.configure-args`
 
 [GitHub Actions]: https://github.com/rust-lang/rust/actions
-[`jobs.yml`]: https://github.com/rust-lang/rust/blob/master/src/ci/github-actions/jobs.yml
-[`.github/workflows/ci.yml`]: https://github.com/rust-lang/rust/blob/master/.github/workflows/ci.yml
-[`src/ci/citool`]: https://github.com/rust-lang/rust/blob/master/src/ci/citool
+[`jobs.yml`]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/github-actions/jobs.yml
+[`.github/workflows/ci.yml`]: https://github.com/rust-lang/rust/blob/HEAD/.github/workflows/ci.yml
+[`src/ci/citool`]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/citool
 [bors]: https://github.com/bors
 [homu]: https://github.com/rust-lang/homu
 [merge queue]: https://bors.rust-lang.org/queue/rust
-[dist-x86_64-linux]: https://github.com/rust-lang/rust/blob/master/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
+[dist-x86_64-linux]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
 [the GitHub Actions workflows page]: https://github.com/rust-lang/rust/actions
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 0234b394c2a05..c2aee82bdd744 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -54,8 +54,8 @@ incremental compilation. The various suites are defined in
 
 The following test suites are available, with links for more information:
 
-[`tests`]: https://github.com/rust-lang/rust/blob/master/tests
-[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/common.rs
+[`tests`]: https://github.com/rust-lang/rust/blob/HEAD/tests
+[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest/src/common.rs
 
 ### Compiler-specific test suites
 
@@ -135,7 +135,7 @@ The directives for pretty-printing tests are:
   of the two pretty-printing rounds will be compared to ensure that the
   pretty-printed output converges to a steady state.
 
-[`tests/pretty`]: https://github.com/rust-lang/rust/tree/master/tests/pretty
+[`tests/pretty`]: https://github.com/rust-lang/rust/tree/HEAD/tests/pretty
 
 ### Incremental tests
 
@@ -187,7 +187,7 @@ still pass.
 cause an Internal Compiler Error (ICE). This is a highly specialized directive
 to check that the incremental cache continues to work after an ICE.
 
-[`tests/incremental`]: https://github.com/rust-lang/rust/tree/master/tests/incremental
+[`tests/incremental`]: https://github.com/rust-lang/rust/tree/HEAD/tests/incremental
 
 
 ### Debuginfo tests
@@ -272,7 +272,7 @@ For example, `./x test tests/debuginfo -- --debugger gdb` will only test GDB com
 > 
 > Otherwise the lldb debuginfo tests can produce crashes in mysterious ways.
 
-[`tests/debuginfo`]: https://github.com/rust-lang/rust/tree/master/tests/debuginfo
+[`tests/debuginfo`]: https://github.com/rust-lang/rust/tree/HEAD/tests/debuginfo
 
 > **Note on acquiring `cdb.exe` on Windows 11**
 >
@@ -299,7 +299,7 @@ See also the [assembly tests](#assembly-tests) for a similar set of tests.
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
-[`tests/codegen-llvm`]: https://github.com/rust-lang/rust/tree/master/tests/codegen-llvm
+[`tests/codegen-llvm`]: https://github.com/rust-lang/rust/tree/HEAD/tests/codegen-llvm
 [FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
 
 
@@ -322,7 +322,7 @@ See also the [codegen tests](#codegen-tests) for a similar set of tests.
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
-[`tests/assembly-llvm`]: https://github.com/rust-lang/rust/tree/master/tests/assembly-llvm
+[`tests/assembly-llvm`]: https://github.com/rust-lang/rust/tree/HEAD/tests/assembly-llvm
 
 
 ### Codegen-units tests
@@ -343,7 +343,7 @@ where `cgu` is a space separated list of the CGU names and the linkage
 information in brackets. For example: `//~ MONO_ITEM static function::FOO @@
 statics[Internal]`
 
-[`tests/codegen-units`]: https://github.com/rust-lang/rust/tree/master/tests/codegen-units
+[`tests/codegen-units`]: https://github.com/rust-lang/rust/tree/HEAD/tests/codegen-units
 
 
 ### Mir-opt tests
@@ -392,7 +392,7 @@ problematic in the presence of pointers in constants or other bit width
 dependent things. In that case you can add `// EMIT_MIR_FOR_EACH_BIT_WIDTH` to
 your test, causing separate files to be generated for 32bit and 64bit systems.
 
-[`tests/mir-opt`]: https://github.com/rust-lang/rust/tree/master/tests/mir-opt
+[`tests/mir-opt`]: https://github.com/rust-lang/rust/tree/HEAD/tests/mir-opt
 
 
 ### `run-make` tests
@@ -481,9 +481,9 @@ Then add a corresponding entry to `"rust-analyzer.linkedProjects"`
 ],
 ```
 
-[`tests/run-make`]: https://github.com/rust-lang/rust/tree/master/tests/run-make
-[`tests/run-make-cargo`]: https://github.com/rust-lang/rust/tree/master/tests/run-make-cargo
-[`run_make_support`]: https://github.com/rust-lang/rust/tree/master/src/tools/run-make-support
+[`tests/run-make`]: https://github.com/rust-lang/rust/tree/HEAD/tests/run-make
+[`tests/run-make-cargo`]: https://github.com/rust-lang/rust/tree/HEAD/tests/run-make-cargo
+[`run_make_support`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/run-make-support
 
 ### Coverage tests
 
@@ -553,9 +553,9 @@ The tests in [`tests/coverage-run-rustdoc`] also run instrumented doctests and
 include them in the coverage report. This avoids having to build rustdoc when
 only running the main `coverage` suite.
 
-[`tests/coverage`]: https://github.com/rust-lang/rust/tree/master/tests/coverage
-[`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/master/src/tools/coverage-dump
-[`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/master/tests/coverage-run-rustdoc
+[`tests/coverage`]: https://github.com/rust-lang/rust/tree/HEAD/tests/coverage
+[`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/coverage-dump
+[`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/HEAD/tests/coverage-run-rustdoc
 
 ### Crash tests
 
@@ -602,7 +602,7 @@ Make sure that your fix actually fixes the root cause of the issue and not just
 a subset first. The issue numbers can be found in the file name or the `//@
 known-bug` directive inside the test file.
 
-[`tests/crashes`]: https://github.com/rust-lang/rust/tree/master/tests/crashes
+[`tests/crashes`]: https://github.com/rust-lang/rust/tree/HEAD/tests/crashes
 ["untracked" crashes]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+state%3Aopen+label%3AI-ICE%2CI-crash+label%3AT-compiler+label%3AS-has-mcve+-label%3AS-bug-has-test
 [labeling]: https://forge.rust-lang.org/release/issue-triaging.html#applying-and-removing-labels
 
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 045c8c71f9cd2..b6273c66db674 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -38,7 +38,7 @@ sections that describe the command in more detail if available. This list may
 not be exhaustive. Directives can generally be found by browsing the
 `TestProps` structure found in [`directives.rs`] from the compiletest source.
 
-[`directives.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
+[`directives.rs`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest/src/directives.rs
 
 ### Assembly
 
@@ -385,7 +385,7 @@ described below:
   - Example: `x86_64-unknown-linux-gnu`
 
 See
-[`tests/ui/argfile/commandline-argfile.rs`](https://github.com/rust-lang/rust/blob/master/tests/ui/argfile/commandline-argfile.rs)
+[`tests/ui/argfile/commandline-argfile.rs`](https://github.com/rust-lang/rust/blob/HEAD/tests/ui/argfile/commandline-argfile.rs)
 for an example of a test that uses this substitution.
 
 [output normalization]: ui.md#normalization
@@ -534,6 +534,6 @@ example, `//@ failure-status: 1`, `self.props.failure_status` will evaluate to
 1, as `parse_failure_status()` will have overridden the `TestProps` default
 value, for that test specifically.
 
-[`src/tools/compiletest/src/directives.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
-[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/common.rs
-[`src/tools/compiletest/src/runtest.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/runtest.rs
+[`src/tools/compiletest/src/directives.rs`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest/src/directives.rs
+[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest/src/common.rs
+[`src/tools/compiletest/src/runtest.rs`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/compiletest/src/runtest.rs
diff --git a/src/doc/rustc-dev-guide/src/tests/docker.md b/src/doc/rustc-dev-guide/src/tests/docker.md
index ae0939842237e..af8e0c36d0500 100644
--- a/src/doc/rustc-dev-guide/src/tests/docker.md
+++ b/src/doc/rustc-dev-guide/src/tests/docker.md
@@ -54,7 +54,7 @@ Some additional notes about using the interactive mode:
   /bin/bash` where `<CONTAINER>` is the container name like `4ba195e95cef`.
 
 [Docker]: https://www.docker.com/
-[`src/ci/docker`]: https://github.com/rust-lang/rust/tree/master/src/ci/docker
-[`src/ci/docker/run.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/docker/run.sh
-[`src/ci/run.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/run.sh
-[`enable-docker-ipv6.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/scripts/enable-docker-ipv6.sh
+[`src/ci/docker`]: https://github.com/rust-lang/rust/tree/HEAD/src/ci/docker
+[`src/ci/docker/run.sh`]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/docker/run.sh
+[`src/ci/run.sh`]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/run.sh
+[`enable-docker-ipv6.sh`]: https://github.com/rust-lang/rust/blob/HEAD/src/ci/scripts/enable-docker-ipv6.sh
diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index 4fa63b83b17fb..c13f8bde29945 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -24,7 +24,7 @@ The [Compiletest chapter][compiletest] goes into detail on how to use this tool.
 > Example: `./x test tests/ui`
 
 [compiletest]: compiletest.md
-[`tests`]: https://github.com/rust-lang/rust/tree/master/tests
+[`tests`]: https://github.com/rust-lang/rust/tree/HEAD/tests
 
 ### Package tests
 
@@ -64,7 +64,7 @@ package tests:
 * `--doc` — Only runs documentation tests in the package.
 * `--no-doc` — Run all tests *except* documentation tests.
 
-[tidy-unit-tests]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/src/unit_tests.rs
+[tidy-unit-tests]: https://github.com/rust-lang/rust/blob/HEAD/src/tools/tidy/src/unit_tests.rs
 
 ### Tidy
 
@@ -74,7 +74,7 @@ conventions, such as rejecting long lines. There is more information in the
 
 > Examples: `./x test tidy`
 
-[Tidy Readme]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/Readme.md
+[Tidy Readme]: https://github.com/rust-lang/rust/blob/HEAD/src/tools/tidy/Readme.md
 
 
 ### Formatting
@@ -142,7 +142,7 @@ In CI, some tools are allowed to fail. Failures send notifications to the
 corresponding teams, and is tracked on the [toolstate website]. More information
 can be found in the [toolstate documentation].
 
-[`src/tools`]: https://github.com/rust-lang/rust/tree/master/src/tools/
+[`src/tools`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/
 [toolstate documentation]: https://forge.rust-lang.org/infra/toolstate.html
 [toolstate website]: https://rust-lang-nursery.github.io/rust-toolstate/
 
diff --git a/src/doc/rustc-dev-guide/src/tests/minicore.md b/src/doc/rustc-dev-guide/src/tests/minicore.md
index 7d71efdd11936..28570376f7c6b 100644
--- a/src/doc/rustc-dev-guide/src/tests/minicore.md
+++ b/src/doc/rustc-dev-guide/src/tests/minicore.md
@@ -71,4 +71,4 @@ impl Copy for Meow {} // `Copy` here is provided by `minicore`
 fn meow() {}
 ```
 
-[`minicore`]: https://github.com/rust-lang/rust/tree/master/tests/auxiliary/minicore.rs
+[`minicore`]: https://github.com/rust-lang/rust/tree/HEAD/tests/auxiliary/minicore.rs
diff --git a/src/doc/rustc-dev-guide/src/tests/running.md b/src/doc/rustc-dev-guide/src/tests/running.md
index 5c1d667685cec..0a99c847cce7e 100644
--- a/src/doc/rustc-dev-guide/src/tests/running.md
+++ b/src/doc/rustc-dev-guide/src/tests/running.md
@@ -368,11 +368,11 @@ export TEST_DEVICE_ADDR="127.0.0.1:12345"
 # FIXME(madsmtm): Allow debuginfo tests to work (maybe needs `.dSYM` folder to be copied to the target?).
 ```
 
-[armhf-gnu]: https://github.com/rust-lang/rust/tree/master/src/ci/docker/host-x86_64/armhf-gnu/Dockerfile
+[armhf-gnu]: https://github.com/rust-lang/rust/tree/HEAD/src/ci/docker/host-x86_64/armhf-gnu/Dockerfile
 [QEMU]: https://www.qemu.org/
-[remote-test-client]: https://github.com/rust-lang/rust/tree/master/src/tools/remote-test-client
-[remote-test-server]: https://github.com/rust-lang/rust/tree/master/src/tools/remote-test-server
-[src/bootstrap/src/core/build_steps/test.rs]: https://github.com/rust-lang/rust/blob/master/src/bootstrap/src/core/build_steps/test.rs
+[remote-test-client]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/remote-test-client
+[remote-test-server]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/remote-test-server
+[src/bootstrap/src/core/build_steps/test.rs]: https://github.com/rust-lang/rust/blob/HEAD/src/bootstrap/src/core/build_steps/test.rs
 
 ## Testing tests on wasi (wasm32-wasip1)
 
@@ -393,7 +393,7 @@ In my case I git-cloned it next to my rust folder, so it was `../wasi-sdk/build/
 Now, tests should just run, you don't have to set up anything else.
 
 [wasi sdk repository]: https://github.com/WebAssembly/wasi-sdk
-[wasm32-wasip1 target support page]: https://github.com/rust-lang/rust/blob/master/src/doc/rustc/src/platform-support/wasm32-wasip1.md#building-the-target.
+[wasm32-wasip1 target support page]: https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustc/src/platform-support/wasm32-wasip1.md#building-the-target.
 
 
-[`tests/ui`]: https://github.com/rust-lang/rust/tree/master/tests/ui
+[`tests/ui`]: https://github.com/rust-lang/rust/tree/HEAD/tests/ui
diff --git a/src/doc/rustc-dev-guide/src/tests/ui.md b/src/doc/rustc-dev-guide/src/tests/ui.md
index d3a2c406402d4..497e6109446ef 100644
--- a/src/doc/rustc-dev-guide/src/tests/ui.md
+++ b/src/doc/rustc-dev-guide/src/tests/ui.md
@@ -12,14 +12,14 @@ the resulting program](#controlling-passfail-expectations) to verify its
 behavior.
 
 For a survey of each subdirectory's purpose under `tests/ui`, consult the
-[SUMMARY.md](https://github.com/rust-lang/rust/tree/master/tests/ui/SUMMARY.md).
+[SUMMARY.md](https://github.com/rust-lang/rust/tree/HEAD/tests/ui/SUMMARY.md).
 This is useful if you write a new test, and are looking for a category to
 place it in.
 
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
-[`tests/ui`]: https://github.com/rust-lang/rust/blob/master/tests/ui
+[`tests/ui`]: https://github.com/rust-lang/rust/blob/HEAD/tests/ui
 
 ## General structure of a test
 
@@ -174,8 +174,8 @@ The corresponding reference file will use the normalized output to test both
 Please see [`ui/transmute/main.rs`][mrs] and [`main.stderr`] for a concrete
 usage example.
 
-[mrs]: https://github.com/rust-lang/rust/blob/master/tests/ui/transmute/main.rs
-[`main.stderr`]: https://github.com/rust-lang/rust/blob/master/tests/ui/transmute/main.stderr
+[mrs]: https://github.com/rust-lang/rust/blob/HEAD/tests/ui/transmute/main.rs
+[`main.stderr`]: https://github.com/rust-lang/rust/blob/HEAD/tests/ui/transmute/main.stderr
 
 ## Error annotations
 
@@ -548,7 +548,7 @@ For example, if your test is related to closures, you should put it in
 `tests/ui/closures`. When you reach the limit, you could increase it by tweaking
 [here][ui test tidy].
 
-[ui test tidy]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/src/ui_tests.rs
+[ui test tidy]: https://github.com/rust-lang/rust/blob/HEAD/src/tools/tidy/src/ui_tests.rs
 
 ## Rustfix tests
 
diff --git a/src/doc/rustc-dev-guide/src/tracing.md b/src/doc/rustc-dev-guide/src/tracing.md
index a7cdab73e7973..4d52f9c865081 100644
--- a/src/doc/rustc-dev-guide/src/tracing.md
+++ b/src/doc/rustc-dev-guide/src/tracing.md
@@ -80,7 +80,7 @@ RUSTC_LOG=[typeck{key=.*name_of_item.*}]
 
 Different queries have different arguments. You can find a list of queries and
 their arguments in
-[`rustc_middle/src/query/mod.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/query/mod.rs#L18).
+[`rustc_middle/src/query/mod.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_middle/src/query/mod.rs#L18).
 
 ## Broad module level filters
 
diff --git a/src/doc/rustc-dev-guide/src/traits/chalk.md b/src/doc/rustc-dev-guide/src/traits/chalk.md
index ca5ed52591734..d0abe423ed45a 100644
--- a/src/doc/rustc-dev-guide/src/traits/chalk.md
+++ b/src/doc/rustc-dev-guide/src/traits/chalk.md
@@ -38,4 +38,4 @@ implementing them in rustc. We map our struct, trait, and impl declarations
 into logical inference rules in the lowering module in rustc.
 
 [chalk]: https://github.com/rust-lang/chalk
-[rustc_traits]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_traits
+[rustc_traits]: https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_traits
diff --git a/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md b/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md
index 2884ca5a05a1f..9dbb62a7e3af8 100644
--- a/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md
+++ b/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md
@@ -42,7 +42,7 @@ In terms of code, these types are defined in
 [`chalk-ir/src/lib.rs`][chalk_ir] in chalk.
 
 [pphhf]: https://rust-lang.github.io/chalk/book/bibliography.html#pphhf
-[traits_mod]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/traits/mod.rs
+[traits_mod]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_middle/src/traits/mod.rs
 [chalk_ir]: https://github.com/rust-lang/chalk/blob/master/chalk-ir/src/lib.rs
 
 <a id="domain-goals"></a>
diff --git a/src/doc/rustc-dev-guide/src/ty-fold.md b/src/doc/rustc-dev-guide/src/ty-fold.md
index 23253022ffe27..120a266e3536a 100644
--- a/src/doc/rustc-dev-guide/src/ty-fold.md
+++ b/src/doc/rustc-dev-guide/src/ty-fold.md
@@ -104,7 +104,7 @@ and all that does is index into the list of substitutions with the index of the
 [`TypeFolder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait.TypeFolder.html
 [`fold_ty`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait.TypeFolder.html#method.fold_ty
 [`ArgFolder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_type_ir/binder/struct.ArgFolder.html
-[here]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_macros/src/type_foldable.rs
+[here]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_macros/src/type_foldable.rs
 [actual folder]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L440-L451
 [fold_ty]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L512-L536
 [ty_for_param]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L552-L587
diff --git a/src/doc/rustc-dev-guide/src/unsafety-checking.md b/src/doc/rustc-dev-guide/src/unsafety-checking.md
index fbc19d8961c59..ed05f8a4c865a 100644
--- a/src/doc/rustc-dev-guide/src/unsafety-checking.md
+++ b/src/doc/rustc-dev-guide/src/unsafety-checking.md
@@ -75,4 +75,4 @@ the ast that searches for unsafe blocks, functions and implementations, as well
 as certain unsafe attributes.
 
 [Unsafe traits]: https://doc.rust-lang.org/reference/items/traits.html#unsafe-traits
-[coherence]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
+[coherence]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
diff --git a/src/doc/rustc-dev-guide/src/walkthrough.md b/src/doc/rustc-dev-guide/src/walkthrough.md
index b4c3379347ed2..d050f9dad4590 100644
--- a/src/doc/rustc-dev-guide/src/walkthrough.md
+++ b/src/doc/rustc-dev-guide/src/walkthrough.md
@@ -271,4 +271,4 @@ about the feature.
 
 Steps to stabilize the feature can be found at [Stabilizing Features](./stabilization_guide.md).
 
-[relnotes]: https://github.com/rust-lang/rust/blob/master/RELEASES.md
+[relnotes]: https://github.com/rust-lang/rust/blob/HEAD/RELEASES.md
diff --git a/src/doc/rustc/book.toml b/src/doc/rustc/book.toml
index 01f127ad39054..34c57a63c97bb 100644
--- a/src/doc/rustc/book.toml
+++ b/src/doc/rustc/book.toml
@@ -4,8 +4,8 @@ src = "src"
 title = "The rustc book"
 
 [output.html]
-git-repository-url = "https://github.com/rust-lang/rust/tree/master/src/doc/rustc"
-edit-url-template = "https://github.com/rust-lang/rust/edit/master/src/doc/rustc/{path}"
+git-repository-url = "https://github.com/rust-lang/rust/tree/HEAD/src/doc/rustc"
+edit-url-template = "https://github.com/rust-lang/rust/edit/HEAD/src/doc/rustc/{path}"
 additional-css = ["theme/pagetoc.css"]
 additional-js = ["theme/pagetoc.js"]
 
diff --git a/src/doc/rustc/src/codegen-options/index.md b/src/doc/rustc/src/codegen-options/index.md
index 0e340de4daa27..f2cf1d447aa5a 100644
--- a/src/doc/rustc/src/codegen-options/index.md
+++ b/src/doc/rustc/src/codegen-options/index.md
@@ -501,7 +501,7 @@ By default, `rustc` prefers to statically link dependencies. This option will
 indicate that dynamic linking should be used if possible if both a static and
 dynamic versions of a library are available.
 
-There is [an internal algorithm](https://github.com/rust-lang/rust/blob/master/compiler/rustc_metadata/src/dependency_format.rs)
+There is [an internal algorithm](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_metadata/src/dependency_format.rs)
 for determining whether or not it is possible to statically or dynamically link
 with a dependency.
 
diff --git a/src/doc/rustc/src/contributing.md b/src/doc/rustc/src/contributing.md
index 3b552e7cc0a74..892c5019dcc37 100644
--- a/src/doc/rustc/src/contributing.md
+++ b/src/doc/rustc/src/contributing.md
@@ -9,4 +9,4 @@ If you would like to contribute to _this_ book, you can find its source in the
 rustc source at [src/doc/rustc][rustc_book].
 
 [rustc_dev_guide]: https://rustc-dev-guide.rust-lang.org/
-[rustc_book]: https://github.com/rust-lang/rust/tree/master/src/doc/rustc
+[rustc_book]: https://github.com/rust-lang/rust/tree/HEAD/src/doc/rustc
diff --git a/src/doc/rustc/src/exploit-mitigations.md b/src/doc/rustc/src/exploit-mitigations.md
index c80d7d8743cd9..41e5c93a1b7dc 100644
--- a/src/doc/rustc/src/exploit-mitigations.md
+++ b/src/doc/rustc/src/exploit-mitigations.md
@@ -66,7 +66,7 @@ equivalent.
 | Forward-edge control flow protection | Yes | No, `-Z sanitizer=cfi` | Nightly |
 | Backward-edge control flow protection (e.g., shadow and safe stack) | Yes | No, `-Z sanitizer=shadow-call-stack,safestack` | Nightly |
 
-[^all-targets]: See <https://github.com/rust-lang/rust/tree/master/compiler/rustc_target/src/spec>
+[^all-targets]: See <https://github.com/rust-lang/rust/tree/HEAD/compiler/rustc_target/src/spec>
     for a list of targets and their default options.
 
 ### Position-independent executable
diff --git a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
index cd0623f73a1db..9244a63c41b35 100644
--- a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
+++ b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
@@ -20,7 +20,7 @@ BE8 architecture is the default big-endian architecture for Arm since [Armv6](ht
 The target is cross-compiled. This target supports `std` in the normal way (indeed only nominal changes are required from the standard Arm configuration).
 
 ## Target definition
-The target definition can be seen [here](https://github.com/rust-lang/rust/blob/master/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs). In particular, it should be noted that the `features` specify that this target is built for the Armv8 core. Though this can likely be modified as required.
+The target definition can be seen [here](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs). In particular, it should be noted that the `features` specify that this target is built for the Armv8 core. Though this can likely be modified as required.
 
 ## Building the target
 Because it is Tier 3, rust does not yet ship pre-compiled artifacts for this target.
diff --git a/src/doc/rustc/src/target-tier-policy.md b/src/doc/rustc/src/target-tier-policy.md
index f6b78eed24fc4..ed725258fa7fb 100644
--- a/src/doc/rustc/src/target-tier-policy.md
+++ b/src/doc/rustc/src/target-tier-policy.md
@@ -133,9 +133,9 @@ target's existence, and add `std` support as a follow-up once you've added
 support for the target in `cc` and `libc`.
 
 [tier3example]: https://github.com/rust-lang/rust/pull/94872
-[platform_template]: https://github.com/rust-lang/rust/blob/master/src/doc/rustc/src/platform-support/TEMPLATE.md
-[summary]: https://github.com/rust-lang/rust/blob/master/src/doc/rustc/src/SUMMARY.md
-[platformsupport]: https://github.com/rust-lang/rust/blob/master/src/doc/rustc/src/platform-support.md
+[platform_template]: https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustc/src/platform-support/TEMPLATE.md
+[summary]: https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustc/src/SUMMARY.md
+[platformsupport]: https://github.com/rust-lang/rust/blob/HEAD/src/doc/rustc/src/platform-support.md
 [rust_compiler_team]: https://www.rust-lang.org/governance/teams/compiler
 [`rust-lang/rust`]: https://github.com/rust-lang/rust
 [rustc_dev_guide_add_target]: https://rustc-dev-guide.rust-lang.org/building/new-target.html
diff --git a/src/doc/rustdoc/book.toml b/src/doc/rustdoc/book.toml
index dfa6857850083..381e9cb227a2e 100644
--- a/src/doc/rustdoc/book.toml
+++ b/src/doc/rustdoc/book.toml
@@ -3,7 +3,7 @@ src = "src"
 title = "The rustdoc book"
 
 [output.html]
-git-repository-url = "https://github.com/rust-lang/rust/tree/master/src/doc/rustdoc"
+git-repository-url = "https://github.com/rust-lang/rust/tree/HEAD/src/doc/rustdoc"
 
 [output.html.redirect]
 "/what-to-include.html" = "write-documentation/what-to-include.html"
diff --git a/src/doc/rustdoc/src/write-documentation/what-to-include.md b/src/doc/rustdoc/src/write-documentation/what-to-include.md
index 75d3b7dae61ed..3a814d81becca 100644
--- a/src/doc/rustdoc/src/write-documentation/what-to-include.md
+++ b/src/doc/rustdoc/src/write-documentation/what-to-include.md
@@ -117,7 +117,7 @@ rustdoc --theme awesome.css src/lib.rs
 
 Here is an example of a new theme, [Ayu].
 
-[Ayu]: https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/static/css/rustdoc.css#L2384-L2574
+[Ayu]: https://github.com/rust-lang/rust/blob/HEAD/src/librustdoc/html/static/css/rustdoc.css#L2384-L2574
 [API Guidelines]: https://rust-lang.github.io/api-guidelines/documentation.html#rustdoc-does-not-show-unhelpful-implementation-details-c-hidden
 [Documentation tests]: documentation-tests.md
 [on this blog]: https://blog.guillaume-gomez.fr/articles/2016-09-16+Generating+doc+with+rustdoc+and+a+custom+theme
diff --git a/src/doc/unstable-book/book.toml b/src/doc/unstable-book/book.toml
index cef93760b33fc..5dbe90cd10ec6 100644
--- a/src/doc/unstable-book/book.toml
+++ b/src/doc/unstable-book/book.toml
@@ -3,5 +3,5 @@ title = "The Rust Unstable Book"
 author = "The Rust Community"
 
 [output.html]
-git-repository-url = "https://github.com/rust-lang/rust/tree/master/src/doc/unstable-book"
-edit-url-template = "https://github.com/rust-lang/rust/edit/master/src/doc/unstable-book/{path}"
+git-repository-url = "https://github.com/rust-lang/rust/tree/HEAD/src/doc/unstable-book"
+edit-url-template = "https://github.com/rust-lang/rust/edit/HEAD/src/doc/unstable-book/{path}"
diff --git a/src/doc/unstable-book/src/compiler-flags/codegen-backend.md b/src/doc/unstable-book/src/compiler-flags/codegen-backend.md
index 7e4be9841f475..59a188a1b111a 100644
--- a/src/doc/unstable-book/src/compiler-flags/codegen-backend.md
+++ b/src/doc/unstable-book/src/compiler-flags/codegen-backend.md
@@ -14,7 +14,7 @@ named `__rustc_codegen_backend` with a signature of `fn() -> Box<dyn rustc_codeg
 ## Example
 See also the [`codegen-backend/hotplug`] test for a working example.
 
-[`codegen-backend/hotplug`]: https://github.com/rust-lang/rust/tree/master/tests/ui-fulldeps/codegen-backend/hotplug.rs
+[`codegen-backend/hotplug`]: https://github.com/rust-lang/rust/tree/HEAD/tests/ui-fulldeps/codegen-backend/hotplug.rs
 
 ```rust,ignore (partial-example)
 use rustc_codegen_ssa::traits::CodegenBackend;
diff --git a/src/doc/unstable-book/src/language-features/lang-items.md b/src/doc/unstable-book/src/language-features/lang-items.md
index 1122bbc5a8786..ee4d976dfd246 100644
--- a/src/doc/unstable-book/src/language-features/lang-items.md
+++ b/src/doc/unstable-book/src/language-features/lang-items.md
@@ -37,7 +37,7 @@ Most lang items are defined by `core`, but if you're trying to build
 an executable without the `std` crate, you might run into the need
 for lang item definitions.
 
-[personality]: https://github.com/rust-lang/rust/blob/master/library/std/src/sys/personality/gcc.rs
+[personality]: https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/personality/gcc.rs
 
 ## Example: Implementing a `Box`
 
@@ -113,4 +113,4 @@ return a valid pointer, and so needs to do the check internally.
 
 An up-to-date list of all language items can be found [here] in the compiler code.
 
-[here]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_hir/src/lang_items.rs
+[here]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_hir/src/lang_items.rs
diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 5aad54fbfee26..3e9d88788655d 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -476,7 +476,7 @@ class MSVCEnumSyntheticProvider:
     Synthetic provider for sum-type enums on MSVC. For a detailed explanation of the internals,
     see:
 
-    https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs
+    https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs
     """
 
     __slots__ = ["valobj", "variant", "value"]
diff --git a/src/etc/natvis/libstd.natvis b/src/etc/natvis/libstd.natvis
index 4719a479c476b..93e94e5f38261 100644
--- a/src/etc/natvis/libstd.natvis
+++ b/src/etc/natvis/libstd.natvis
@@ -18,8 +18,8 @@
     look/feel at the std type level *anyways*...
 
     References:
-      https://github.com/rust-lang/rust/blob/master/src/libstd/collections/hash/map.rs
-      https://github.com/rust-lang/rust/blob/master/src/libstd/collections/hash/set.rs
+      https://github.com/rust-lang/rust/blob/HEAD/src/libstd/collections/hash/map.rs
+      https://github.com/rust-lang/rust/blob/HEAD/src/libstd/collections/hash/set.rs
       https://github.com/rust-lang/hashbrown/blob/master/src/map.rs
       https://github.com/rust-lang/hashbrown/blob/master/src/set.rs
       https://github.com/rust-lang/hashbrown/blob/master/src/raw/mod.rs
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 6c280c0736b18..bdffd690ddf28 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -60,7 +60,7 @@ extern crate rustc_target;
 extern crate rustc_trait_selection;
 extern crate test;
 
-// See docs in https://github.com/rust-lang/rust/blob/master/compiler/rustc/src/main.rs
+// See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
 // about jemalloc.
 #[cfg(feature = "jemalloc")]
 extern crate tikv_jemalloc_sys as jemalloc_sys;
@@ -123,7 +123,7 @@ mod visit_ast;
 mod visit_lib;
 
 pub fn main() {
-    // See docs in https://github.com/rust-lang/rust/blob/master/compiler/rustc/src/main.rs
+    // See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
     // about jemalloc.
     #[cfg(feature = "jemalloc")]
     {
diff --git a/src/rustc-std-workspace/rustc-std-workspace-alloc/Cargo.toml b/src/rustc-std-workspace/rustc-std-workspace-alloc/Cargo.toml
index 1a8ebdcfeae3e..ec39a36aecbad 100644
--- a/src/rustc-std-workspace/rustc-std-workspace-alloc/Cargo.toml
+++ b/src/rustc-std-workspace/rustc-std-workspace-alloc/Cargo.toml
@@ -8,4 +8,4 @@ description = """
 crate for integration of crates.io crates into rust-lang/rust standard library workspace
 """
 
-repository = "https://github.com/rust-lang/rust/tree/master/src/rustc-std-workspace"
+repository = "https://github.com/rust-lang/rust/tree/HEAD/src/rustc-std-workspace"
diff --git a/src/rustc-std-workspace/rustc-std-workspace-core/Cargo.toml b/src/rustc-std-workspace/rustc-std-workspace-core/Cargo.toml
index 116cf3fb6bcda..040dff5f218d2 100644
--- a/src/rustc-std-workspace/rustc-std-workspace-core/Cargo.toml
+++ b/src/rustc-std-workspace/rustc-std-workspace-core/Cargo.toml
@@ -8,4 +8,4 @@ description = """
 crate for integration of crates.io crates into rust-lang/rust standard library workspace
 """
 
-repository = "https://github.com/rust-lang/rust/tree/master/src/rustc-std-workspace"
+repository = "https://github.com/rust-lang/rust/tree/HEAD/src/rustc-std-workspace"
diff --git a/src/rustc-std-workspace/rustc-std-workspace-std/Cargo.toml b/src/rustc-std-workspace/rustc-std-workspace-std/Cargo.toml
index fcd1ca3deaf5a..a0cf35d237538 100644
--- a/src/rustc-std-workspace/rustc-std-workspace-std/Cargo.toml
+++ b/src/rustc-std-workspace/rustc-std-workspace-std/Cargo.toml
@@ -8,4 +8,4 @@ description = """
 crate for integration of crates.io crates into rust-lang/rust standard library workspace
 """
 
-repository = "https://github.com/rust-lang/rust/tree/master/src/rustc-std-workspace"
+repository = "https://github.com/rust-lang/rust/tree/HEAD/src/rustc-std-workspace"
diff --git a/src/tools/clippy/book/src/development/infrastructure/changelog_update.md b/src/tools/clippy/book/src/development/infrastructure/changelog_update.md
index c96ff228b01af..9eb7e7cc9c9eb 100644
--- a/src/tools/clippy/book/src/development/infrastructure/changelog_update.md
+++ b/src/tools/clippy/book/src/development/infrastructure/changelog_update.md
@@ -112,7 +112,7 @@ written for. If not, update the version to the changelog version.
 
 [changelog]: https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md
 [forge]: https://forge.rust-lang.org/
-[rust_master_tools]: https://github.com/rust-lang/rust/tree/master/src/tools/clippy
+[rust_master_tools]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/clippy
 [rust_beta_tools]: https://github.com/rust-lang/rust/tree/beta/src/tools/clippy
 [rust_stable_tools]: https://github.com/rust-lang/rust/releases
 [`beta-accepted`]: https://github.com/rust-lang/rust-clippy/issues?q=label%3Abeta-accepted+
diff --git a/src/tools/clippy/clippy_lints/src/disallowed_script_idents.rs b/src/tools/clippy/clippy_lints/src/disallowed_script_idents.rs
index cf964d4b58044..5b4fe2a6b8036 100644
--- a/src/tools/clippy/clippy_lints/src/disallowed_script_idents.rs
+++ b/src/tools/clippy/clippy_lints/src/disallowed_script_idents.rs
@@ -67,7 +67,7 @@ impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
 impl EarlyLintPass for DisallowedScriptIdents {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
         // Implementation is heavily inspired by the implementation of [`non_ascii_idents`] lint:
-        // https://github.com/rust-lang/rust/blob/master/compiler/rustc_lint/src/non_ascii_idents.rs
+        // https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_lint/src/non_ascii_idents.rs
 
         let check_disallowed_script_idents = cx.builder.lint_level(DISALLOWED_SCRIPT_IDENTS).level != Level::Allow;
         if !check_disallowed_script_idents {
diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs
index 102ca3fa69f7e..abc706b7772f1 100644
--- a/src/tools/clippy/src/driver.rs
+++ b/src/tools/clippy/src/driver.rs
@@ -13,7 +13,7 @@ extern crate rustc_interface;
 extern crate rustc_session;
 extern crate rustc_span;
 
-// See docs in https://github.com/rust-lang/rust/blob/master/compiler/rustc/src/main.rs
+// See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
 // about jemalloc.
 #[cfg(feature = "jemalloc")]
 extern crate tikv_jemalloc_sys as jemalloc_sys;
@@ -189,7 +189,7 @@ const BUG_REPORT_URL: &str = "https://github.com/rust-lang/rust-clippy/issues/ne
 
 #[expect(clippy::too_many_lines)]
 pub fn main() {
-    // See docs in https://github.com/rust-lang/rust/blob/master/compiler/rustc/src/main.rs
+    // See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
     // about jemalloc.
     #[cfg(feature = "jemalloc")]
     {
diff --git a/src/tools/miri/src/shims/io_error.rs b/src/tools/miri/src/shims/io_error.rs
index e597b527cb7a8..91ae448e21651 100644
--- a/src/tools/miri/src/shims/io_error.rs
+++ b/src/tools/miri/src/shims/io_error.rs
@@ -56,7 +56,7 @@ impl From<Scalar> for IoError {
 }
 
 // This mapping should match `decode_error_kind` in
-// <https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/unix/mod.rs>.
+// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/pal/unix/mod.rs>.
 const UNIX_IO_ERROR_TABLE: &[(&str, std::io::ErrorKind)] = {
     use std::io::ErrorKind::*;
     &[
@@ -103,7 +103,7 @@ const UNIX_IO_ERROR_TABLE: &[(&str, std::io::ErrorKind)] = {
     ]
 };
 // This mapping should match `decode_error_kind` in
-// <https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/windows/mod.rs>.
+// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/pal/windows/mod.rs>.
 const WINDOWS_IO_ERROR_TABLE: &[(&str, std::io::ErrorKind)] = {
     use std::io::ErrorKind::*;
     // It's common for multiple error codes to map to the same io::ErrorKind. We have all for the
diff --git a/src/tools/nix-dev-shell/x/default.nix b/src/tools/nix-dev-shell/x/default.nix
index 422c1c4a2aed8..9573ddd2825d6 100644
--- a/src/tools/nix-dev-shell/x/default.nix
+++ b/src/tools/nix-dev-shell/x/default.nix
@@ -76,7 +76,7 @@ stdenv.mkDerivation (self: {
 
   meta = {
     description = "Helper for rust-lang/rust x.py";
-    homepage = "https://github.com/rust-lang/rust/blob/master/src/tools/x";
+    homepage = "https://github.com/rust-lang/rust/blob/HEAD/src/tools/x";
     license = lib.licenses.mit;
     mainProgram = "x";
   };
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe/meta_syntax.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe/meta_syntax.rs
index 2c94f0e8d0986..9997455432f7d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe/meta_syntax.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe/meta_syntax.rs
@@ -98,7 +98,7 @@ macro_rules! m2 { () => ( ${invalid()} ) }
 
 #[test]
 fn test_rustc_issue_57597() {
-    // <https://github.com/rust-lang/rust/blob/master/tests/ui/issues/issue-57597.rs>
+    // <https://github.com/rust-lang/rust/blob/HEAD/tests/ui/issues/issue-57597.rs>
     check(
         r#"
 macro_rules! m0 { ($($($i:ident)?)+) => {}; }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
index 14bc380586aa0..5eb7e92ffb096 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
@@ -7511,7 +7511,7 @@ Most lang items are defined by `core`, but if you're trying to build
 an executable without the `std` crate, you might run into the need
 for lang item definitions.
 
-[personality]: https://github.com/rust-lang/rust/blob/master/library/std/src/sys/personality/gcc.rs
+[personality]: https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/personality/gcc.rs
 
 ## Example: Implementing a `Box`
 
@@ -7586,7 +7586,7 @@ return a valid pointer, and so needs to do the check internally.
 
 An up-to-date list of all language items can be found [here] in the compiler code.
 
-[here]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_hir/src/lang_items.rs
+[here]: https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_hir/src/lang_items.rs
 "##,
         default_severity: Severity::Allow,
         warn_since: None,
diff --git a/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md b/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
index befb631ec03d8..74489a9046ba3 100644
--- a/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
+++ b/src/tools/rust-analyzer/docs/book/src/non_cargo_based_projects.md
@@ -31,7 +31,7 @@ interface ProjectJson {
     /// It should point to the directory where std,
     /// core, and friends can be found:
     ///
-    /// https://github.com/rust-lang/rust/tree/master/library.
+    /// https://github.com/rust-lang/rust/tree/HEAD/library.
     ///
     /// If provided, rust-analyzer automatically adds
     /// dependencies on sysroot crates. Conversely,
diff --git a/src/tools/rustfmt/Configurations.md b/src/tools/rustfmt/Configurations.md
index b1f5406039274..dd5ce73df0fca 100644
--- a/src/tools/rustfmt/Configurations.md
+++ b/src/tools/rustfmt/Configurations.md
@@ -2422,7 +2422,7 @@ See also [`max_width`](#max_width) and [`use_small_heuristics`](#use_small_heuri
 ## `single_line_let_else_max_width`
 
 Maximum line length for single line let-else statements.
-See the [let-else statement section of the Rust Style Guide](https://github.com/rust-lang/rust/blob/master/src/doc/style-guide/src/statements.md#else-blocks-let-else-statements) for more details on when a let-else statement may be written on a single line.
+See the [let-else statement section of the Rust Style Guide](https://github.com/rust-lang/rust/blob/HEAD/src/doc/style-guide/src/statements.md#else-blocks-let-else-statements) for more details on when a let-else statement may be written on a single line.
 A value of `0` (zero) means the divergent `else` block will always be formatted over multiple lines.
 Note this occurs when `use_small_heuristics` is set to `Off`.
 
diff --git a/src/tools/rustfmt/Contributing.md b/src/tools/rustfmt/Contributing.md
index 85754a8658a5e..212c5d0068372 100644
--- a/src/tools/rustfmt/Contributing.md
+++ b/src/tools/rustfmt/Contributing.md
@@ -157,7 +157,7 @@ format.
 
 There are different nodes for every kind of item and expression in Rust. For
 more details see the source code in the compiler -
-[ast.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/ast.rs) - and/or the
+[ast.rs](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_ast/src/ast.rs) - and/or the
 [docs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/index.html).
 
 Many nodes in the AST (but not all, annoyingly) have a `Span`. A `Span` is a
diff --git a/src/tools/rustfmt/src/closures.rs b/src/tools/rustfmt/src/closures.rs
index bb10a7946b810..e219cacc1557d 100644
--- a/src/tools/rustfmt/src/closures.rs
+++ b/src/tools/rustfmt/src/closures.rs
@@ -480,7 +480,7 @@ fn is_block_closure_forced_inner(expr: &ast::Expr, style_edition: StyleEdition)
 ///     if true {...} else {...}
 ///      |x| 5
 /// isn't parsed as (if true {...} else {...} | x) | 5
-// From https://github.com/rust-lang/rust/blob/master/src/libsyntax/parse/classify.rs.
+// From https://github.com/rust-lang/rust/blob/HEAD/src/libsyntax/parse/classify.rs.
 fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
     match e.kind {
         ast::ExprKind::If(..)
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
index 895558f3b0fcb..646688604674c 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
@@ -58,7 +58,20 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
index 821ab6fa57cd0..d0e7edf42cdd5 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
@@ -38,7 +38,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
index b39be78e4384c..e8b5c09699202 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
@@ -56,6 +56,14 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 10 |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+ 3 | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+ 4 |     fn a(&self);
+   |     ------------ this method is not const
+   = help: const traits are not yet supported on stable Rust
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 6 previous errors
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
index 30ee5cf6f4b0c..263532f3a9400 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
@@ -46,6 +46,14 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 10 |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+ 3 | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+ 4 |     fn a(&self);
+   |     ------------ this method is not const
+   = help: const traits are not yet supported on stable Rust
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 5 previous errors
diff --git a/tests/ui/asm/non-const.stderr b/tests/ui/asm/non-const.stderr
index eac4fe841bffd..d7a901ba20ee5 100644
--- a/tests/ui/asm/non-const.stderr
+++ b/tests/ui/asm/non-const.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `non_const_fn` in constants
 LL | global_asm!("/* {} */", const non_const_fn(0));
    |                               ^^^^^^^^^^^^^^^
    |
+note: function `non_const_fn` is not const
+  --> $DIR/non-const.rs:8:1
+   |
+LL | fn non_const_fn(x: i32) -> i32 { x }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/borrowck/issue-64453.stderr b/tests/ui/borrowck/issue-64453.stderr
index 8ec9a10f09f4d..29a7363705cd7 100644
--- a/tests/ui/borrowck/issue-64453.stderr
+++ b/tests/ui/borrowck/issue-64453.stderr
@@ -4,6 +4,8 @@ error[E0015]: cannot call non-const function `format` in statics
 LL | static settings_dir: String = format!("");
    |                               ^^^^^^^^^^^
    |
+note: function `format` is not const
+  --> $SRC_DIR/alloc/src/fmt.rs:LL:COL
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/const-generics/early/const-param-from-outer-fn.stderr b/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
index faba4ce10a1b4..3c25dff41aa22 100644
--- a/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
+++ b/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<const X: u32>() {
    |              - const parameter from outer item
 LL |     fn bar() -> u32 {
-   |           - help: try introducing a local generic parameter here: `<X>`
+   |        --- generic parameter used in this inner function
 LL |         X
    |         ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<X>() -> u32 {
+   |           +++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-call.stderr b/tests/ui/consts/const-call.stderr
index b9dcf5addb519..cc80f73d0bb61 100644
--- a/tests/ui/consts/const-call.stderr
+++ b/tests/ui/consts/const-call.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `f` in constants
 LL |     let _ = [0; f(2)];
    |                 ^^^^
    |
+note: function `f` is not const
+  --> $DIR/const-call.rs:1:1
+   |
+LL | fn f(x: usize) -> usize {
+   | ^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/const-eval/format.stderr b/tests/ui/consts/const-eval/format.stderr
index bd50ac0bf4116..ea191eb5c0989 100644
--- a/tests/ui/consts/const-eval/format.stderr
+++ b/tests/ui/consts/const-eval/format.stderr
@@ -21,6 +21,8 @@ error[E0015]: cannot call non-const function `_print` in constant functions
 LL |     println!("{:?}", 0);
    |     ^^^^^^^^^^^^^^^^^^^
    |
+note: function `_print` is not const
+  --> $SRC_DIR/std/src/io/stdio.rs:LL:COL
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
index 1fa881cf42b6a..ac0d344d8f480 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `regular_in_block` in constant func
 LL |         regular_in_block();
    |         ^^^^^^^^^^^^^^^^^^
    |
+note: function `regular_in_block` is not const
+  --> $DIR/const-extern-fn-call-extern-fn.rs:2:5
+   |
+LL |     fn regular_in_block();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error[E0015]: cannot call non-const function `regular` in constant functions
@@ -12,6 +17,11 @@ error[E0015]: cannot call non-const function `regular` in constant functions
 LL |         regular();
    |         ^^^^^^^^^
    |
+note: function `regular` is not const
+  --> $DIR/const-extern-fn-call-extern-fn.rs:12:1
+   |
+LL | extern "C" fn regular() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/consts/const-fn-not-safe-for-const.stderr b/tests/ui/consts/const-fn-not-safe-for-const.stderr
index e8f0566e73dd8..8fd27df5367e0 100644
--- a/tests/ui/consts/const-fn-not-safe-for-const.stderr
+++ b/tests/ui/consts/const-fn-not-safe-for-const.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `random` in constant functions
 LL |     random()
    |     ^^^^^^^^
    |
+note: function `random` is not const
+  --> $DIR/const-fn-not-safe-for-const.rs:5:1
+   |
+LL | fn random() -> u32 {
+   | ^^^^^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/const_cmp_type_id.stderr b/tests/ui/consts/const_cmp_type_id.stderr
index 62a1677c0d930..b991b6af08cc1 100644
--- a/tests/ui/consts/const_cmp_type_id.stderr
+++ b/tests/ui/consts/const_cmp_type_id.stderr
@@ -3,6 +3,9 @@ error[E0277]: the trait bound `TypeId: const PartialOrd` is not satisfied
    |
 LL |         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: trait `PartialOrd` is implemented but not `const`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/control-flow/issue-46843.stderr b/tests/ui/consts/control-flow/issue-46843.stderr
index 42eb035647c0e..46b2a6bf1fd36 100644
--- a/tests/ui/consts/control-flow/issue-46843.stderr
+++ b/tests/ui/consts/control-flow/issue-46843.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `non_const` in constants
 LL | pub const Q: i32 = match non_const() {
    |                          ^^^^^^^^^^^
    |
+note: function `non_const` is not const
+  --> $DIR/issue-46843.rs:6:1
+   |
+LL | fn non_const() -> Thing {
+   | ^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/issue-16538.stderr b/tests/ui/consts/issue-16538.stderr
index 8bd11541a7dff..fd97b4360a468 100644
--- a/tests/ui/consts/issue-16538.stderr
+++ b/tests/ui/consts/issue-16538.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `Y::foo` in statics
 LL | static foo: &Y::X = &*Y::foo(Y::x as *const Y::X);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+note: function `foo` is not const
+  --> $DIR/issue-16538.rs:6:5
+   |
+LL |     pub fn foo(value: *const X) -> *const X {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
diff --git a/tests/ui/consts/issue-32829-2.stderr b/tests/ui/consts/issue-32829-2.stderr
index eedd9d34e550e..b201454866ed5 100644
--- a/tests/ui/consts/issue-32829-2.stderr
+++ b/tests/ui/consts/issue-32829-2.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `invalid` in constants
 LL |         invalid();
    |         ^^^^^^^^^
    |
+note: function `invalid` is not const
+  --> $DIR/issue-32829-2.rs:68:1
+   |
+LL | fn invalid() {}
+   | ^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error[E0015]: cannot call non-const function `invalid` in statics
@@ -12,6 +17,11 @@ error[E0015]: cannot call non-const function `invalid` in statics
 LL |         invalid();
    |         ^^^^^^^^^
    |
+note: function `invalid` is not const
+  --> $DIR/issue-32829-2.rs:68:1
+   |
+LL | fn invalid() {}
+   | ^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
@@ -21,6 +31,11 @@ error[E0015]: cannot call non-const function `invalid` in statics
 LL |         invalid();
    |         ^^^^^^^^^
    |
+note: function `invalid` is not const
+  --> $DIR/issue-32829-2.rs:68:1
+   |
+LL | fn invalid() {}
+   | ^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
diff --git a/tests/ui/consts/issue-43105.stderr b/tests/ui/consts/issue-43105.stderr
index c030c0f5fcdec..7ec0a2b73afc5 100644
--- a/tests/ui/consts/issue-43105.stderr
+++ b/tests/ui/consts/issue-43105.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `xyz` in constants
 LL | const NUM: u8 = xyz();
    |                 ^^^^^
    |
+note: function `xyz` is not const
+  --> $DIR/issue-43105.rs:1:1
+   |
+LL | fn xyz() -> u8 { 42 }
+   | ^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/mir_check_nonconst.stderr b/tests/ui/consts/mir_check_nonconst.stderr
index e930fa2103d5d..bb0940ee789b9 100644
--- a/tests/ui/consts/mir_check_nonconst.stderr
+++ b/tests/ui/consts/mir_check_nonconst.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `bar` in statics
 LL | static foo: Foo = bar();
    |                   ^^^^^
    |
+note: function `bar` is not const
+  --> $DIR/mir_check_nonconst.rs:4:1
+   |
+LL | fn bar() -> Foo {
+   | ^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
diff --git a/tests/ui/delegation/target-expr.stderr b/tests/ui/delegation/target-expr.stderr
index f5556bf9f4514..edd1a584eab26 100644
--- a/tests/ui/delegation/target-expr.stderr
+++ b/tests/ui/delegation/target-expr.stderr
@@ -4,7 +4,7 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn bar<T: Default>(_: T) {
    |        - type parameter from outer item
 LL |     reuse Trait::static_method {
-   |                               - help: try introducing a local generic parameter here: `T,`
+   |                  ------------- generic parameter used in this inner delegated function
 LL |
 LL |         let _ = T::Default();
    |                 ^^^^^^^^^^ use of generic parameter from outer item
diff --git a/tests/ui/error-codes/E0015.stderr b/tests/ui/error-codes/E0015.stderr
index 0c983d2843492..bc457aefaecb0 100644
--- a/tests/ui/error-codes/E0015.stderr
+++ b/tests/ui/error-codes/E0015.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `create_some` in constants
 LL | const FOO: Option<u8> = create_some();
    |                         ^^^^^^^^^^^^^
    |
+note: function `create_some` is not const
+  --> $DIR/E0015.rs:1:1
+   |
+LL | fn create_some() -> Option<u8> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/error-codes/E0401.stderr b/tests/ui/error-codes/E0401.stderr
index 5d6878620c89a..8daaf09df1592 100644
--- a/tests/ui/error-codes/E0401.stderr
+++ b/tests/ui/error-codes/E0401.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>(x: T) {
    |        - type parameter from outer item
 LL |     fn bfnr<U, V: Baz<U>, W: Fn()>(y: T) {
-   |             -                         ^ use of generic parameter from outer item
-   |             |
-   |             help: try introducing a local generic parameter here: `T,`
+   |        ----                           ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bfnr<T, U, V: Baz<U>, W: Fn()>(y: T) {
+   |             ++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/E0401.rs:9:16
@@ -15,10 +20,15 @@ LL | fn foo<T>(x: T) {
    |        - type parameter from outer item
 ...
 LL |     fn baz<U,
-   |            - help: try introducing a local generic parameter here: `T,`
+   |        --- generic parameter used in this inner function
 ...
 LL |            (y: T) {
    |                ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn baz<T, U,
+   |            ++
 
 error[E0401]: can't use `Self` from outer item
   --> $DIR/E0401.rs:22:25
@@ -27,10 +37,11 @@ LL | impl<T> Iterator for A<T> {
    | ---- `Self` type implicitly declared here, by this `impl`
 ...
 LL |         fn helper(sel: &Self) -> u8 {
-   |                         ^^^^
-   |                         |
-   |                         use of `Self` from outer item
-   |                         refer to the type directly here instead
+   |            ------       ^^^^
+   |            |            |
+   |            |            use of `Self` from outer item
+   |            |            refer to the type directly here instead
+   |            `Self` used in this inner function
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/explicit-tail-calls/become-cast-return.rs b/tests/ui/explicit-tail-calls/become-cast-return.rs
new file mode 100644
index 0000000000000..d4cdcbf3a0112
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/become-cast-return.rs
@@ -0,0 +1,22 @@
+//@ run-pass
+//@ ignore-backends: gcc
+//@ ignore-wasm 'tail-call' feature not enabled in target wasm32-wasip1
+//@ ignore-cross-compile
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+#[inline(never)]
+fn leaf(_: &Box<u8>) -> [u8; 1] {
+    [1]
+}
+
+#[inline(never)]
+fn dispatch(param: &Box<u8>) -> [u8; 1] {
+    become leaf(param)
+}
+
+fn main() {
+    let data = Box::new(0);
+    let out = dispatch(&data);
+    assert_eq!(out, [1]);
+}
diff --git a/tests/ui/explicit-tail-calls/become-indirect-return.rs b/tests/ui/explicit-tail-calls/become-indirect-return.rs
new file mode 100644
index 0000000000000..b1e552bca0293
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/become-indirect-return.rs
@@ -0,0 +1,22 @@
+//@ run-pass
+//@ ignore-backends: gcc
+//@ ignore-wasm 'tail-call' feature not enabled in target wasm32-wasip1
+//@ ignore-cross-compile
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+#[inline(never)]
+fn op_dummy(_param: &Box<u8>) -> [u8; 24] {
+    [1; 24]
+}
+
+#[inline(never)]
+fn dispatch(param: &Box<u8>) -> [u8; 24] {
+    become op_dummy(param)
+}
+
+fn main() {
+    let param = Box::new(0);
+    let result = dispatch(&param);
+    assert_eq!(result, [1; 24]);
+}
diff --git a/tests/ui/explicit-tail-calls/constck.stderr b/tests/ui/explicit-tail-calls/constck.stderr
index c223d273b383f..2fc2fb7f9338b 100644
--- a/tests/ui/explicit-tail-calls/constck.stderr
+++ b/tests/ui/explicit-tail-calls/constck.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `not_const` in constant functions
 LL |         become not_const();
    |                ^^^^^^^^^^^
    |
+note: function `not_const` is not const
+  --> $DIR/constck.rs:18:1
+   |
+LL | fn not_const() {}
+   | ^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error[E0015]: cannot call non-const function `not_const` in constant functions
@@ -12,6 +17,11 @@ error[E0015]: cannot call non-const function `not_const` in constant functions
 LL |         become yes_const(not_const());
    |                          ^^^^^^^^^^^
    |
+note: function `not_const` is not const
+  --> $DIR/constck.rs:18:1
+   |
+LL | fn not_const() {}
+   | ^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/generics/enum-definition-with-outer-generic-parameter-5997.stderr b/tests/ui/generics/enum-definition-with-outer-generic-parameter-5997.stderr
index aea0f049b07d3..fb2d2f247b65b 100644
--- a/tests/ui/generics/enum-definition-with-outer-generic-parameter-5997.stderr
+++ b/tests/ui/generics/enum-definition-with-outer-generic-parameter-5997.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn f<Z>() -> bool {
    |      - type parameter from outer item
 LL |     enum E { V(Z) }
-   |           -    ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<Z>`
+   |          -     ^ use of generic parameter from outer item
+   |          |
+   |          generic parameter used in this inner enum
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     enum E<Z> { V(Z) }
+   |           +++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/generic-params-nested-fn-scope-error.stderr b/tests/ui/generics/generic-params-nested-fn-scope-error.stderr
index 7fd1069c651fa..f809740ed381f 100644
--- a/tests/ui/generics/generic-params-nested-fn-scope-error.stderr
+++ b/tests/ui/generics/generic-params-nested-fn-scope-error.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<U>(v: Vec<U>) -> U {
    |        - type parameter from outer item
 LL |     fn bar(w: [U]) -> U {
-   |           -    ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<U>`
+   |        ---     ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<U>(w: [U]) -> U {
+   |           +++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/generic-params-nested-fn-scope-error.rs:5:23
@@ -14,9 +19,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<U>(v: Vec<U>) -> U {
    |        - type parameter from outer item
 LL |     fn bar(w: [U]) -> U {
-   |           -           ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<U>`
+   |        ---            ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<U>(w: [U]) -> U {
+   |           +++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/generics/issue-98432.stderr b/tests/ui/generics/issue-98432.stderr
index 2b09d43960f62..a1efee78cb7df 100644
--- a/tests/ui/generics/issue-98432.stderr
+++ b/tests/ui/generics/issue-98432.stderr
@@ -5,9 +5,14 @@ LL | impl<T> Struct<T> {
    |      - type parameter from outer item
 LL |     const CONST: fn() = || {
 LL |         struct _Obligation where T:;
-   |                           -      ^ use of generic parameter from outer item
-   |                           |
-   |                           help: try introducing a local generic parameter here: `<T>`
+   |                -----------       ^ use of generic parameter from outer item
+   |                |
+   |                generic parameter used in this inner struct
+   |
+help: try introducing a local generic parameter here
+   |
+LL |         struct _Obligation<T> where T:;
+   |                           +++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/missing-param-but-has-colon-144215.rs b/tests/ui/generics/missing-param-but-has-colon-144215.rs
new file mode 100644
index 0000000000000..31a9dd49e5c65
--- /dev/null
+++ b/tests/ui/generics/missing-param-but-has-colon-144215.rs
@@ -0,0 +1,9 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/144215>
+
+#[rustfmt::skip]
+struct S<T:>(&'static T);
+//~^ ERROR the parameter type `T` may not live long enough
+//~| HELP consider adding an explicit lifetime bound
+//~| SUGGESTION  'static
+
+fn main() {}
diff --git a/tests/ui/generics/missing-param-but-has-colon-144215.stderr b/tests/ui/generics/missing-param-but-has-colon-144215.stderr
new file mode 100644
index 0000000000000..bf6cee035e2e6
--- /dev/null
+++ b/tests/ui/generics/missing-param-but-has-colon-144215.stderr
@@ -0,0 +1,17 @@
+error[E0310]: the parameter type `T` may not live long enough
+  --> $DIR/missing-param-but-has-colon-144215.rs:4:14
+   |
+LL | struct S<T:>(&'static T);
+   |              ^^^^^^^^^^
+   |              |
+   |              the parameter type `T` must be valid for the static lifetime...
+   |              ...so that the reference type `&'static T` does not outlive the data it points at
+   |
+help: consider adding an explicit lifetime bound
+   |
+LL | struct S<T: 'static>(&'static T);
+   |             +++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/malformed/do-not-ice-on-note_and_explain.stderr b/tests/ui/malformed/do-not-ice-on-note_and_explain.stderr
index 11a8c01e49094..63de7099797ca 100644
--- a/tests/ui/malformed/do-not-ice-on-note_and_explain.stderr
+++ b/tests/ui/malformed/do-not-ice-on-note_and_explain.stderr
@@ -3,7 +3,9 @@ error[E0401]: can't reference `Self` constructor from outer item
    |
 LL | impl<B> A<B> {
    | ------------ the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
-...
+LL |     fn d() {
+LL |         fn d() {
+   |            - `Self` used in this inner item
 LL |             Self(1)
    |             ^^^^ help: replace `Self` with the actual type: `A`
 
diff --git a/tests/ui/resolve/bad-type-env-capture.stderr b/tests/ui/resolve/bad-type-env-capture.stderr
index 3f9bc9149c24a..c565997ca2a26 100644
--- a/tests/ui/resolve/bad-type-env-capture.stderr
+++ b/tests/ui/resolve/bad-type-env-capture.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>() {
    |        - type parameter from outer item
 LL |     fn bar(b: T) { }
-   |           -   ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<T>`
+   |        ---    ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<T>(b: T) { }
+   |           +++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/generic-params-from-outer-item-in-const-item.default.stderr b/tests/ui/resolve/generic-params-from-outer-item-in-const-item.default.stderr
index fbb9ede8aa175..bc67e9dce4e3b 100644
--- a/tests/ui/resolve/generic-params-from-outer-item-in-const-item.default.stderr
+++ b/tests/ui/resolve/generic-params-from-outer-item-in-const-item.default.stderr
@@ -4,7 +4,9 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn outer<T: Tr>() { // outer function
    |          - type parameter from outer item
 LL |     const K: u32 = T::C;
-   |                    ^^^^ use of generic parameter from outer item
+   |           -        ^^^^ use of generic parameter from outer item
+   |           |
+   |           generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
 
@@ -15,7 +17,9 @@ LL | impl<T> Tr for T { // outer impl block
    |      - type parameter from outer item
 LL |     const C: u32 = {
 LL |         const I: u32 = T::C;
-   |                        ^^^^ use of generic parameter from outer item
+   |               -        ^^^^ use of generic parameter from outer item
+   |               |
+   |               generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
 
@@ -25,7 +29,9 @@ error[E0401]: can't use generic parameters from outer item
 LL | struct S<T: Tr>(U32<{ // outer struct
    |          - type parameter from outer item
 LL |     const _: u32 = T::C;
-   |                    ^^^^ use of generic parameter from outer item
+   |           -        ^^^^ use of generic parameter from outer item
+   |           |
+   |           generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
 
diff --git a/tests/ui/resolve/generic-params-from-outer-item-in-const-item.generic_const_items.stderr b/tests/ui/resolve/generic-params-from-outer-item-in-const-item.generic_const_items.stderr
index 60aa94038c3ad..3959d117c7c9a 100644
--- a/tests/ui/resolve/generic-params-from-outer-item-in-const-item.generic_const_items.stderr
+++ b/tests/ui/resolve/generic-params-from-outer-item-in-const-item.generic_const_items.stderr
@@ -4,11 +4,15 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn outer<T: Tr>() { // outer function
    |          - type parameter from outer item
 LL |     const K: u32 = T::C;
-   |            -       ^^^^ use of generic parameter from outer item
-   |            |
-   |            help: try introducing a local generic parameter here: `<T>`
+   |           -        ^^^^ use of generic parameter from outer item
+   |           |
+   |           generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
+help: try introducing a local generic parameter here
+   |
+LL |     const K<T>: u32 = T::C;
+   |            +++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/generic-params-from-outer-item-in-const-item.rs:19:24
@@ -17,11 +21,15 @@ LL | impl<T> Tr for T { // outer impl block
    |      - type parameter from outer item
 LL |     const C: u32 = {
 LL |         const I: u32 = T::C;
-   |                -       ^^^^ use of generic parameter from outer item
-   |                |
-   |                help: try introducing a local generic parameter here: `<T>`
+   |               -        ^^^^ use of generic parameter from outer item
+   |               |
+   |               generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
+help: try introducing a local generic parameter here
+   |
+LL |         const I<T>: u32 = T::C;
+   |                +++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/generic-params-from-outer-item-in-const-item.rs:27:20
@@ -29,11 +37,15 @@ error[E0401]: can't use generic parameters from outer item
 LL | struct S<T: Tr>(U32<{ // outer struct
    |          - type parameter from outer item
 LL |     const _: u32 = T::C;
-   |            -       ^^^^ use of generic parameter from outer item
-   |            |
-   |            help: try introducing a local generic parameter here: `<T>`
+   |           -        ^^^^ use of generic parameter from outer item
+   |           |
+   |           generic parameter used in this inner constant item
    |
    = note: a `const` is a separate item from the item that contains it
+help: try introducing a local generic parameter here
+   |
+LL |     const _<T>: u32 = T::C;
+   |            +++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/resolve/issue-12796.stderr b/tests/ui/resolve/issue-12796.stderr
index 2305971303a71..b5828c6f5fc86 100644
--- a/tests/ui/resolve/issue-12796.stderr
+++ b/tests/ui/resolve/issue-12796.stderr
@@ -2,10 +2,11 @@ error[E0401]: can't use `Self` from outer item
   --> $DIR/issue-12796.rs:3:22
    |
 LL |         fn inner(_: &Self) {
-   |                      ^^^^
-   |                      |
-   |                      use of `Self` from outer item
-   |                      can't use `Self` here
+   |            -----     ^^^^
+   |            |         |
+   |            |         use of `Self` from outer item
+   |            |         can't use `Self` here
+   |            `Self` used in this inner function
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/issue-3021-c.stderr b/tests/ui/resolve/issue-3021-c.stderr
index 537bbaf7b6a56..8c554fd1b97dc 100644
--- a/tests/ui/resolve/issue-3021-c.stderr
+++ b/tests/ui/resolve/issue-3021-c.stderr
@@ -5,9 +5,14 @@ LL | fn siphash<T>() {
    |            - type parameter from outer item
 LL |
 LL |     trait U {
-   |            - help: try introducing a local generic parameter here: `<T>`
+   |           - generic parameter used in this inner trait
 LL |         fn g(&self, x: T) -> T;
    |                        ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     trait U<T> {
+   |            +++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/issue-3021-c.rs:4:30
@@ -16,9 +21,14 @@ LL | fn siphash<T>() {
    |            - type parameter from outer item
 LL |
 LL |     trait U {
-   |            - help: try introducing a local generic parameter here: `<T>`
+   |           - generic parameter used in this inner trait
 LL |         fn g(&self, x: T) -> T;
    |                              ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     trait U<T> {
+   |            +++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/resolve/issue-3214.stderr b/tests/ui/resolve/issue-3214.stderr
index 1c64fdc1711fd..ab12676bdd805 100644
--- a/tests/ui/resolve/issue-3214.stderr
+++ b/tests/ui/resolve/issue-3214.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>() {
    |        - type parameter from outer item
 LL |     struct Foo {
-   |               - help: try introducing a local generic parameter here: `<T>`
+   |            --- generic parameter used in this inner struct
 LL |         x: T,
    |            ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     struct Foo<T> {
+   |               +++
 
 error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied
   --> $DIR/issue-3214.rs:6:22
diff --git a/tests/ui/resolve/issue-39559-2.stderr b/tests/ui/resolve/issue-39559-2.stderr
index f6e6917d01e6d..4bfa1d1b1322f 100644
--- a/tests/ui/resolve/issue-39559-2.stderr
+++ b/tests/ui/resolve/issue-39559-2.stderr
@@ -4,7 +4,20 @@ error[E0015]: cannot call non-const associated function `<Dim3 as Dim>::dim` in
 LL |     let array: [usize; Dim3::dim()]
    |                        ^^^^^^^^^^^
    |
+note: associated function `dim` is not const because trait `Dim` is not const
+  --> $DIR/issue-39559-2.rs:1:1
+   |
+LL | trait Dim {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn dim() -> usize;
+   |     ------------------ this associated function is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Dim` const
+   |
+LL + #[const_trait]
+LL | trait Dim {
+   |
 
 error[E0015]: cannot call non-const associated function `<Dim3 as Dim>::dim` in constants
   --> $DIR/issue-39559-2.rs:16:15
@@ -12,7 +25,20 @@ error[E0015]: cannot call non-const associated function `<Dim3 as Dim>::dim` in
 LL |         = [0; Dim3::dim()];
    |               ^^^^^^^^^^^
    |
+note: associated function `dim` is not const because trait `Dim` is not const
+  --> $DIR/issue-39559-2.rs:1:1
+   |
+LL | trait Dim {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn dim() -> usize;
+   |     ------------------ this associated function is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Dim` const
+   |
+LL + #[const_trait]
+LL | trait Dim {
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr b/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
index ca32147d19765..2d21ed0155a70 100644
--- a/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
+++ b/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
@@ -1,11 +1,14 @@
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/issue-65025-extern-static-parent-generics.rs:3:28
    |
-LL | unsafe fn foo<A>() {
-   |               - type parameter from outer item
-LL |     extern "C" {
-LL |         static baz: *const A;
-   |                            ^ use of generic parameter from outer item
+LL |   unsafe fn foo<A>() {
+   |                 - type parameter from outer item
+LL | /     extern "C" {
+LL | |         static baz: *const A;
+   | |                            ^ use of generic parameter from outer item
+LL | |
+LL | |     }
+   | |_____- generic parameter used in this inner extern block
    |
    = note: a `static` is a separate item from the item that contains it
 
diff --git a/tests/ui/resolve/issue-65035-static-with-parent-generics.stderr b/tests/ui/resolve/issue-65035-static-with-parent-generics.stderr
index 98ffb4567f164..b22bfb719bd50 100644
--- a/tests/ui/resolve/issue-65035-static-with-parent-generics.stderr
+++ b/tests/ui/resolve/issue-65035-static-with-parent-generics.stderr
@@ -1,11 +1,14 @@
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/issue-65035-static-with-parent-generics.rs:3:26
    |
-LL | fn f<T>() {
-   |      - type parameter from outer item
-LL |     extern "C" {
-LL |         static a: *const T;
-   |                          ^ use of generic parameter from outer item
+LL |   fn f<T>() {
+   |        - type parameter from outer item
+LL | /     extern "C" {
+LL | |         static a: *const T;
+   | |                          ^ use of generic parameter from outer item
+LL | |
+LL | |     }
+   | |_____- generic parameter used in this inner extern block
    |
    = note: a `static` is a separate item from the item that contains it
 
@@ -15,18 +18,23 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn g<T: Default>() {
    |      - type parameter from outer item
 LL |     static a: *const T = Default::default();
-   |                      ^ use of generic parameter from outer item
+   |            -         ^ use of generic parameter from outer item
+   |            |
+   |            generic parameter used in this inner static item
    |
    = note: a `static` is a separate item from the item that contains it
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/issue-65035-static-with-parent-generics.rs:15:24
    |
-LL | fn h<const N: usize>() {
-   |            - const parameter from outer item
-LL |     extern "C" {
-LL |         static a: [u8; N];
-   |                        ^ use of generic parameter from outer item
+LL |   fn h<const N: usize>() {
+   |              - const parameter from outer item
+LL | /     extern "C" {
+LL | |         static a: [u8; N];
+   | |                        ^ use of generic parameter from outer item
+LL | |
+LL | |     }
+   | |_____- generic parameter used in this inner extern block
    |
    = note: a `static` is a separate item from the item that contains it
 
@@ -36,7 +44,9 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn i<const N: usize>() {
    |            - const parameter from outer item
 LL |     static a: [u8; N] = [0; N];
-   |                    ^ use of generic parameter from outer item
+   |            -       ^ use of generic parameter from outer item
+   |            |
+   |            generic parameter used in this inner static item
    |
    = note: a `static` is a separate item from the item that contains it
 
@@ -46,7 +56,9 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn i<const N: usize>() {
    |            - const parameter from outer item
 LL |     static a: [u8; N] = [0; N];
-   |                             ^ use of generic parameter from outer item
+   |            -                ^ use of generic parameter from outer item
+   |            |
+   |            generic parameter used in this inner static item
    |
    = note: a `static` is a separate item from the item that contains it
 
diff --git a/tests/ui/resolve/resolve-type-param-in-item-in-trait.stderr b/tests/ui/resolve/resolve-type-param-in-item-in-trait.stderr
index 1ab56fdc50441..00aa645688e7f 100644
--- a/tests/ui/resolve/resolve-type-param-in-item-in-trait.stderr
+++ b/tests/ui/resolve/resolve-type-param-in-item-in-trait.stderr
@@ -5,9 +5,14 @@ LL | trait TraitA<A> {
    |              - type parameter from outer item
 LL |     fn outer(&self) {
 LL |         enum Foo<B> {
-   |                  - help: try introducing a local generic parameter here: `A,`
+   |              --- generic parameter used in this inner enum
 LL |             Variance(A)
    |                      ^ use of generic parameter from outer item
+   |
+help: try introducing a local generic parameter here
+   |
+LL |         enum Foo<A, B> {
+   |                  ++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/resolve-type-param-in-item-in-trait.rs:16:23
@@ -16,9 +21,14 @@ LL | trait TraitB<A> {
    |              - type parameter from outer item
 LL |     fn outer(&self) {
 LL |         struct Foo<B>(A);
-   |                    -  ^ use of generic parameter from outer item
-   |                    |
-   |                    help: try introducing a local generic parameter here: `A,`
+   |                ---    ^ use of generic parameter from outer item
+   |                |
+   |                generic parameter used in this inner struct
+   |
+help: try introducing a local generic parameter here
+   |
+LL |         struct Foo<A, B>(A);
+   |                    ++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/resolve-type-param-in-item-in-trait.rs:23:28
@@ -27,9 +37,14 @@ LL | trait TraitC<A> {
    |              - type parameter from outer item
 LL |     fn outer(&self) {
 LL |         struct Foo<B> { a: A }
-   |                    -       ^ use of generic parameter from outer item
-   |                    |
-   |                    help: try introducing a local generic parameter here: `A,`
+   |                ---         ^ use of generic parameter from outer item
+   |                |
+   |                generic parameter used in this inner struct
+   |
+help: try introducing a local generic parameter here
+   |
+LL |         struct Foo<A, B> { a: A }
+   |                    ++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/resolve-type-param-in-item-in-trait.rs:30:22
@@ -38,9 +53,14 @@ LL | trait TraitD<A> {
    |              - type parameter from outer item
 LL |     fn outer(&self) {
 LL |         fn foo<B>(a: A) { }
-   |                -     ^ use of generic parameter from outer item
-   |                |
-   |                help: try introducing a local generic parameter here: `A,`
+   |            ---       ^ use of generic parameter from outer item
+   |            |
+   |            generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |         fn foo<A, B>(a: A) { }
+   |                ++
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/resolve/use-self-in-inner-fn.rs b/tests/ui/resolve/use-self-in-inner-fn.rs
index 62f9dc5664ffe..ed64ee885271c 100644
--- a/tests/ui/resolve/use-self-in-inner-fn.rs
+++ b/tests/ui/resolve/use-self-in-inner-fn.rs
@@ -6,6 +6,7 @@ impl A {
         fn peach(this: &Self) {
         //~^ ERROR can't use `Self` from outer item
         //~| NOTE use of `Self` from outer item
+        //~| NOTE `Self` used in this inner function
         //~| NOTE refer to the type directly here instead
         }
     }
diff --git a/tests/ui/resolve/use-self-in-inner-fn.stderr b/tests/ui/resolve/use-self-in-inner-fn.stderr
index 9c388df8bc20c..645875f6e726d 100644
--- a/tests/ui/resolve/use-self-in-inner-fn.stderr
+++ b/tests/ui/resolve/use-self-in-inner-fn.stderr
@@ -5,10 +5,11 @@ LL | impl A {
    | ---- `Self` type implicitly declared here, by this `impl`
 ...
 LL |         fn peach(this: &Self) {
-   |                         ^^^^
-   |                         |
-   |                         use of `Self` from outer item
-   |                         refer to the type directly here instead
+   |            -----        ^^^^
+   |            |            |
+   |            |            use of `Self` from outer item
+   |            |            refer to the type directly here instead
+   |            `Self` used in this inner function
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/self/self-ctor-nongeneric.stderr b/tests/ui/self/self-ctor-nongeneric.stderr
index b53ecbe55b594..c3ae7df2ad25e 100644
--- a/tests/ui/self/self-ctor-nongeneric.stderr
+++ b/tests/ui/self/self-ctor-nongeneric.stderr
@@ -5,7 +5,9 @@ LL | impl S0 {
    | ------- the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
 LL |     fn foo() {
 LL |         const C: S0 = Self(0);
-   |                       ^^^^ help: replace `Self` with the actual type: `S0`
+   |               -       ^^^^ help: replace `Self` with the actual type: `S0`
+   |               |
+   |               `Self` used in this inner item
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124186 <https://github.com/rust-lang/rust/issues/124186>
@@ -17,6 +19,8 @@ warning: can't reference `Self` constructor from outer item
 LL | impl S0 {
    | ------- the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
 ...
+LL |         fn bar() -> S0 {
+   |            --- `Self` used in this inner item
 LL |             Self(0)
    |             ^^^^ help: replace `Self` with the actual type: `S0`
    |
diff --git a/tests/ui/self/self-ctor.stderr b/tests/ui/self/self-ctor.stderr
index 0cb22baaa1a05..b8dfd324c3f36 100644
--- a/tests/ui/self/self-ctor.stderr
+++ b/tests/ui/self/self-ctor.stderr
@@ -5,7 +5,9 @@ LL | impl<T> S0<T> {
    | ------------- the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
 LL |     fn foo() {
 LL |         const C: S0<i32> = Self(0);
-   |                            ^^^^ help: replace `Self` with the actual type: `S0`
+   |               -            ^^^^ help: replace `Self` with the actual type: `S0`
+   |               |
+   |               `Self` used in this inner item
 
 error[E0401]: can't reference `Self` constructor from outer item
   --> $DIR/self-ctor.rs:8:13
@@ -13,6 +15,8 @@ error[E0401]: can't reference `Self` constructor from outer item
 LL | impl<T> S0<T> {
    | ------------- the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
 ...
+LL |         fn bar() -> S0<i32> {
+   |            --- `Self` used in this inner item
 LL |             Self(0)
    |             ^^^^ help: replace `Self` with the actual type: `S0`
 
diff --git a/tests/ui/static/static-vec-repeat-not-constant.stderr b/tests/ui/static/static-vec-repeat-not-constant.stderr
index e6ff199ae0198..fa4033f6a4076 100644
--- a/tests/ui/static/static-vec-repeat-not-constant.stderr
+++ b/tests/ui/static/static-vec-repeat-not-constant.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `foo` in statics
 LL | static a: [isize; 2] = [foo(); 2];
    |                         ^^^^^
    |
+note: function `foo` is not const
+  --> $DIR/static-vec-repeat-not-constant.rs:1:1
+   |
+LL | fn foo() -> isize { 23 }
+   | ^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
diff --git a/tests/ui/statics/check-values-constraints.stderr b/tests/ui/statics/check-values-constraints.stderr
index eb2d37d297e9f..c54f4830533ae 100644
--- a/tests/ui/statics/check-values-constraints.stderr
+++ b/tests/ui/statics/check-values-constraints.stderr
@@ -35,6 +35,13 @@ error[E0015]: cannot call non-const method `<str as ToString>::to_string` in sta
 LL |     field2: SafeEnum::Variant4("str".to_string()),
    |                                      ^^^^^^^^^^^
    |
+note: method `to_string` is not const because trait `ToString` is not const
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
+   |
+   = note: this trait is not const
+  ::: $SRC_DIR/alloc/src/string.rs:LL:COL
+   |
+   = note: this method is not const
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
diff --git a/tests/ui/statics/static-generic-param-soundness.stderr b/tests/ui/statics/static-generic-param-soundness.stderr
index 47554c7fcb0f0..72f65e2bac7cb 100644
--- a/tests/ui/statics/static-generic-param-soundness.stderr
+++ b/tests/ui/statics/static-generic-param-soundness.stderr
@@ -4,7 +4,9 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>() {
    |        - type parameter from outer item
 LL |     static a: Bar<T> = Bar::What;
-   |                   ^ use of generic parameter from outer item
+   |            -      ^ use of generic parameter from outer item
+   |            |
+   |            generic parameter used in this inner static item
    |
    = note: a `static` is a separate item from the item that contains it
 
diff --git a/tests/ui/traits/const-traits/assoc-type.current.stderr b/tests/ui/traits/const-traits/assoc-type.current.stderr
index 1e58efeedeea1..7fe086550f1c2 100644
--- a/tests/ui/traits/const-traits/assoc-type.current.stderr
+++ b/tests/ui/traits/const-traits/assoc-type.current.stderr
@@ -9,6 +9,10 @@ note: required by a bound in `Foo::Bar`
    |
 LL |     type Bar: [const] Add;
    |               ^^^^^^^^^^^ required by this bound in `Foo::Bar`
+help: make the `impl` of trait `Add` `const`
+   |
+LL | impl const Add for NonConstAdd {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/assoc-type.next.stderr b/tests/ui/traits/const-traits/assoc-type.next.stderr
index 1e58efeedeea1..7fe086550f1c2 100644
--- a/tests/ui/traits/const-traits/assoc-type.next.stderr
+++ b/tests/ui/traits/const-traits/assoc-type.next.stderr
@@ -9,6 +9,10 @@ note: required by a bound in `Foo::Bar`
    |
 LL |     type Bar: [const] Add;
    |               ^^^^^^^^^^^ required by this bound in `Foo::Bar`
+help: make the `impl` of trait `Add` `const`
+   |
+LL | impl const Add for NonConstAdd {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/call-const-closure.stderr b/tests/ui/traits/const-traits/call-const-closure.stderr
index 4bb8b2e9777e6..9de22759c2003 100644
--- a/tests/ui/traits/const-traits/call-const-closure.stderr
+++ b/tests/ui/traits/const-traits/call-const-closure.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `(): [const] Bar` is not satisfied
    |
 LL |     (const || ().foo())();
    |                  ^^^
+   |
+help: make the `impl` of trait `Bar` `const`
+   |
+LL | impl const Bar for () {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/call-const-trait-method-fail.stderr b/tests/ui/traits/const-traits/call-const-trait-method-fail.stderr
index 4aaf53344c90a..c6f93629379ac 100644
--- a/tests/ui/traits/const-traits/call-const-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/call-const-trait-method-fail.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `u32: [const] Plus` is not satisfied
    |
 LL |     a.plus(b)
    |     ^
+   |
+help: make the `impl` of trait `Plus` `const`
+   |
+LL | impl const Plus for u32 {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/call-generic-method-fail.stderr b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
index a2fba141f7b89..6e75730b9b513 100644
--- a/tests/ui/traits/const-traits/call-generic-method-fail.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `T: [const] PartialEq` is not satisfied
    |
 LL |     *t == *t
    |     ^^^^^^^^
+   |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/call-generic-method-nonconst.stderr b/tests/ui/traits/const-traits/call-generic-method-nonconst.stderr
index 9c1e0fee9e711..b2ec41182a83b 100644
--- a/tests/ui/traits/const-traits/call-generic-method-nonconst.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-nonconst.stderr
@@ -11,6 +11,10 @@ note: required by a bound in `equals_self`
    |
 LL | const fn equals_self<T: [const] Foo>(t: &T) -> bool {
    |                         ^^^^^^^^^^^ required by this bound in `equals_self`
+help: make the `impl` of trait `Foo` `const`
+   |
+LL | impl const Foo for S {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
index 599a5503b0f33..1a7ec35f3ddba 100644
--- a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
+++ b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `non_const` in constant functions
 LL |     fn foo() { non_const() }
    |                ^^^^^^^^^^^
    |
+note: function `non_const` is not const
+  --> $DIR/const-check-fns-in-const-impl.rs:11:1
+   |
+LL | fn non_const() {}
+   | ^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
index fddd8d10bccc4..faacc86512441 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `(): const Tr` is not satisfied
    |
 LL | const _: () = assert!(need_const_closure(Tr::a) == 42);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the `impl` of trait `Tr` `const`
+   |
+LL | impl const Tr for () {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/const-default-method-bodies.stderr b/tests/ui/traits/const-traits/const-default-method-bodies.stderr
index 03ca6f1d51155..22b6a9b5613a8 100644
--- a/tests/ui/traits/const-traits/const-default-method-bodies.stderr
+++ b/tests/ui/traits/const-traits/const-default-method-bodies.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `NonConstImpl: [const] ConstDefaultFn` is not sati
    |
 LL |     NonConstImpl.a();
    |                  ^
+   |
+help: make the `impl` of trait `ConstDefaultFn` `const`
+   |
+LL | impl const ConstDefaultFn for NonConstImpl {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/const-drop-fail-2.precise.stderr b/tests/ui/traits/const-traits/const-drop-fail-2.precise.stderr
index c2309ea6e122e..48c8852a7b8d4 100644
--- a/tests/ui/traits/const-traits/const-drop-fail-2.precise.stderr
+++ b/tests/ui/traits/const-traits/const-drop-fail-2.precise.stderr
@@ -16,6 +16,10 @@ note: required by a bound in `check`
    |
 LL | const fn check<T: [const] Destruct>(_: T) {}
    |                   ^^^^^^^^^^^^^^^^ required by this bound in `check`
+help: make the `impl` of trait `A` `const`
+   |
+LL | impl const A for NonTrivialDrop {}
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/const-drop-fail-2.stock.stderr b/tests/ui/traits/const-traits/const-drop-fail-2.stock.stderr
index c2309ea6e122e..48c8852a7b8d4 100644
--- a/tests/ui/traits/const-traits/const-drop-fail-2.stock.stderr
+++ b/tests/ui/traits/const-traits/const-drop-fail-2.stock.stderr
@@ -16,6 +16,10 @@ note: required by a bound in `check`
    |
 LL | const fn check<T: [const] Destruct>(_: T) {}
    |                   ^^^^^^^^^^^^^^^^ required by this bound in `check`
+help: make the `impl` of trait `A` `const`
+   |
+LL | impl const A for NonTrivialDrop {}
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/const-opaque.no.stderr b/tests/ui/traits/const-traits/const-opaque.no.stderr
index acf19ba96ab39..591b81f976745 100644
--- a/tests/ui/traits/const-traits/const-opaque.no.stderr
+++ b/tests/ui/traits/const-traits/const-opaque.no.stderr
@@ -11,12 +11,21 @@ note: required by a bound in `bar`
    |
 LL | const fn bar<T: [const] Foo>(t: T) -> impl [const] Foo {
    |                 ^^^^^^^^^^^ required by this bound in `bar`
+help: make the `impl` of trait `Foo` `const`
+   |
+LL | impl const Foo for () {
+   |      +++++
 
 error[E0277]: the trait bound `(): const Foo` is not satisfied
   --> $DIR/const-opaque.rs:33:12
    |
 LL |     opaque.method();
    |            ^^^^^^
+   |
+help: make the `impl` of trait `Foo` `const`
+   |
+LL | impl const Foo for () {
+   |      +++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/traits/const-traits/cross-crate.gatednc.stderr b/tests/ui/traits/const-traits/cross-crate.gatednc.stderr
index 1da519151182a..fe45ff188efb4 100644
--- a/tests/ui/traits/const-traits/cross-crate.gatednc.stderr
+++ b/tests/ui/traits/const-traits/cross-crate.gatednc.stderr
@@ -3,6 +3,12 @@ error[E0277]: the trait bound `cross_crate::NonConst: [const] cross_crate::MyTra
    |
 LL |     NonConst.func();
    |              ^^^^
+   |
+note: trait `MyTrait` is implemented but not `const`
+  --> $DIR/auxiliary/cross-crate.rs:12:1
+   |
+LL | impl MyTrait for NonConst {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/default-method-body-is-const-body-checking.stderr b/tests/ui/traits/const-traits/default-method-body-is-const-body-checking.stderr
index 2e236cecfb475..3ce646ec5027f 100644
--- a/tests/ui/traits/const-traits/default-method-body-is-const-body-checking.stderr
+++ b/tests/ui/traits/const-traits/default-method-body-is-const-body-checking.stderr
@@ -9,6 +9,10 @@ note: required by a bound in `foo`
    |
 LL | const fn foo<T>() where T: [const] Tr {}
    |                            ^^^^^^^^^^ required by this bound in `foo`
+help: make the `impl` of trait `Tr` `const`
+   |
+LL | impl const Tr for () {}
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/default-method-body-is-const-same-trait-ck.stderr b/tests/ui/traits/const-traits/default-method-body-is-const-same-trait-ck.stderr
index 2dc2d48461749..f473a687efcb0 100644
--- a/tests/ui/traits/const-traits/default-method-body-is-const-same-trait-ck.stderr
+++ b/tests/ui/traits/const-traits/default-method-body-is-const-same-trait-ck.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `(): [const] Tr` is not satisfied
    |
 LL |         ().a()
    |            ^
+   |
+help: make the `impl` of trait `Tr` `const`
+   |
+LL | impl const Tr for () {}
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
index ad0829ff05fb0..ca73ae845550d 100644
--- a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
+++ b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
@@ -13,7 +13,19 @@ error[E0015]: cannot call non-const method `<() as Trait>::foo` in constant func
 LL |     ().foo();
    |        ^^^^^
    |
+note: method `foo` is not const because trait `Trait` is not const
+  --> $DIR/inline-incorrect-early-bound-in-ctfe.rs:13:1
+   |
+LL | trait Trait {
+   | ^^^^^^^^^^^ this trait is not const
+LL |     fn foo(self);
+   |     ------------- this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Trait` const
+   |
+LL + #[const_trait]
+LL | trait Trait {
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/traits/const-traits/issue-79450.stderr b/tests/ui/traits/const-traits/issue-79450.stderr
index 5bdebbbfb032b..d8a9e18980687 100644
--- a/tests/ui/traits/const-traits/issue-79450.stderr
+++ b/tests/ui/traits/const-traits/issue-79450.stderr
@@ -4,6 +4,8 @@ error[E0015]: cannot call non-const function `_print` in constant functions
 LL |         println!("lul");
    |         ^^^^^^^^^^^^^^^
    |
+note: function `_print` is not const
+  --> $SRC_DIR/std/src/io/stdio.rs:LL:COL
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/traits/const-traits/issue-88155.stderr b/tests/ui/traits/const-traits/issue-88155.stderr
index 96a3c4187f5c2..4a912cc8274a7 100644
--- a/tests/ui/traits/const-traits/issue-88155.stderr
+++ b/tests/ui/traits/const-traits/issue-88155.stderr
@@ -4,7 +4,19 @@ error[E0015]: cannot call non-const associated function `<T as A>::assoc` in con
 LL |     T::assoc()
    |     ^^^^^^^^^^
    |
+note: associated function `assoc` is not const because trait `A` is not const
+  --> $DIR/issue-88155.rs:3:1
+   |
+LL | pub trait A {
+   | ^^^^^^^^^^^ this trait is not const
+LL |     fn assoc() -> bool;
+   |     ------------------- this associated function is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `A` const
+   |
+LL + #[const_trait]
+LL | pub trait A {
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr b/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
index 8e5894a32966f..3c150c77a6916 100644
--- a/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
+++ b/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
@@ -9,6 +9,10 @@ note: required by a bound in `Foo::Assoc`
    |
 LL |     type Assoc<T>: [const] Bar
    |                    ^^^^^^^^^^^ required by this bound in `Foo::Assoc`
+help: make the `impl` of trait `Bar` `const`
+   |
+LL | impl<T> const Bar for N<T> where T: Bar {}
+   |         +++++
 
 error[E0277]: the trait bound `T: [const] Bar` is not satisfied
   --> $DIR/item-bound-entailment-fails.rs:24:21
diff --git a/tests/ui/traits/const-traits/minicore-deref-fail.stderr b/tests/ui/traits/const-traits/minicore-deref-fail.stderr
index 4329b235756be..e6c087cb9d822 100644
--- a/tests/ui/traits/const-traits/minicore-deref-fail.stderr
+++ b/tests/ui/traits/const-traits/minicore-deref-fail.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `Ty: [const] minicore::Deref` is not satisfied
    |
 LL |     *Ty;
    |     ^^^
+   |
+help: make the `impl` of trait `Deref` `const`
+   |
+LL | impl const Deref for Ty {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/minicore-fn-fail.stderr b/tests/ui/traits/const-traits/minicore-fn-fail.stderr
index c02a067774b56..eb840d421f488 100644
--- a/tests/ui/traits/const-traits/minicore-fn-fail.stderr
+++ b/tests/ui/traits/const-traits/minicore-fn-fail.stderr
@@ -11,6 +11,10 @@ note: required by a bound in `call_indirect`
    |
 LL | const fn call_indirect<T: [const] Fn()>(t: &T) { t() }
    |                           ^^^^^^^^^^^^ required by this bound in `call_indirect`
+help: make the `impl` of trait `Foo` `const`
+   |
+LL | impl const Foo for () {}
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/no-explicit-const-params.stderr b/tests/ui/traits/const-traits/no-explicit-const-params.stderr
index 6955e9ab2985d..47fa65b2479be 100644
--- a/tests/ui/traits/const-traits/no-explicit-const-params.stderr
+++ b/tests/ui/traits/const-traits/no-explicit-const-params.stderr
@@ -59,6 +59,11 @@ error[E0277]: the trait bound `(): const Bar` is not satisfied
    |
 LL |     <() as Bar<false>>::bar();
    |      ^^
+   |
+help: make the `impl` of trait `Bar` `const`
+   |
+LL | impl const Bar for () {
+   |      +++++
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/traits/const-traits/specializing-constness-2.stderr b/tests/ui/traits/const-traits/specializing-constness-2.stderr
index 850e6939daebc..2a34cd1c4f82d 100644
--- a/tests/ui/traits/const-traits/specializing-constness-2.stderr
+++ b/tests/ui/traits/const-traits/specializing-constness-2.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `T: [const] A` is not satisfied
    |
 LL |     <T as A>::a();
    |      ^
+   |
+help: make the `impl` of trait `A` `const`
+   |
+LL | impl<T: Default> const A for T {
+   |                  +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
index 0ecbad64bc853..c9dc239bef334 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
@@ -51,7 +51,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-2.rs:6:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
index 0e5b697d1ddef..bfbf6980ab833 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
@@ -63,7 +63,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-2.rs:6:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
index a0ae60526ef3f..ea487cbd563f2 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
@@ -94,7 +94,20 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-3.rs:17:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
index a0ae60526ef3f..ea487cbd563f2 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
@@ -94,7 +94,20 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-3.rs:17:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
index c8ec77c2f0930..5951caebe7335 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
@@ -74,7 +74,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-3.rs:17:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
index a820239cde012..563495204ad7b 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
@@ -63,7 +63,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> $DIR/super-traits-fail-3.rs:17:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail.stderr b/tests/ui/traits/const-traits/super-traits-fail.stderr
index e19aa30cf95c3..3010a5df0c31f 100644
--- a/tests/ui/traits/const-traits/super-traits-fail.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail.stderr
@@ -3,6 +3,11 @@ error[E0277]: the trait bound `S: [const] Foo` is not satisfied
    |
 LL | impl const Bar for S {}
    |                    ^
+   |
+help: make the `impl` of trait `Foo` `const`
+   |
+LL | impl const Foo for S {
+   |      +++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/ice-index-out-of-bounds-issue-117446.stderr b/tests/ui/traits/ice-index-out-of-bounds-issue-117446.stderr
index ad33a70ed3bb6..2e75003c49b8a 100644
--- a/tests/ui/traits/ice-index-out-of-bounds-issue-117446.stderr
+++ b/tests/ui/traits/ice-index-out-of-bounds-issue-117446.stderr
@@ -24,6 +24,9 @@ error[E0401]: can't reference `Self` constructor from outer item
 LL | impl<'a, T> Foo<'a> for Repeated<T> {
    | ----------------------------------- the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
 ...
+LL |         fn inner<Q>(value: Option<()>) -> Repeated<Q> {
+   |            ----- `Self` used in this inner item
+LL |             match value {
 LL |                 _ => Self(unimplemented!()),
    |                      ^^^^ help: replace `Self` with the actual type: `Repeated`
 
diff --git a/tests/ui/type/type-arg-out-of-scope.stderr b/tests/ui/type/type-arg-out-of-scope.stderr
index fcaaca1770f67..3d8850ebccea5 100644
--- a/tests/ui/type/type-arg-out-of-scope.stderr
+++ b/tests/ui/type/type-arg-out-of-scope.stderr
@@ -4,9 +4,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>(x: T) {
    |        - type parameter from outer item
 LL |     fn bar(f: Box<dyn FnMut(T) -> T>) { }
-   |           -                 ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<T>`
+   |        ---                  ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<T>(f: Box<dyn FnMut(T) -> T>) { }
+   |           +++
 
 error[E0401]: can't use generic parameters from outer item
   --> $DIR/type-arg-out-of-scope.rs:2:35
@@ -14,9 +19,14 @@ error[E0401]: can't use generic parameters from outer item
 LL | fn foo<T>(x: T) {
    |        - type parameter from outer item
 LL |     fn bar(f: Box<dyn FnMut(T) -> T>) { }
-   |           -                       ^ use of generic parameter from outer item
-   |           |
-   |           help: try introducing a local generic parameter here: `<T>`
+   |        ---                        ^ use of generic parameter from outer item
+   |        |
+   |        generic parameter used in this inner function
+   |
+help: try introducing a local generic parameter here
+   |
+LL |     fn bar<T>(f: Box<dyn FnMut(T) -> T>) { }
+   |           +++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index 240dc1ae8ab9e..0b70ac97fd435 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -671,6 +671,11 @@ error[E0015]: cannot call non-const function `map::<u8>` in constants
 LL | const _: Option<_> = map(value);
    |                      ^^^^^^^^^^
    |
+note: function `map` is not const
+  --> $DIR/typeck_type_placeholder_item.rs:222:1
+   |
+LL | fn map<T>(_: fn() -> Option<&'static T>) -> Option<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error[E0015]: cannot call non-const method `<std::ops::Range<i32> as Iterator>::filter::<{closure@$DIR/typeck_type_placeholder_item.rs:240:29: 240:32}>` in constants
@@ -679,6 +684,13 @@ error[E0015]: cannot call non-const method `<std::ops::Range<i32> as Iterator>::
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |
+note: method `filter` is not const because trait `Iterator` is not const
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+   |
+   = note: this trait is not const
+  ::: $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+   |
+   = note: this method is not const
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error[E0015]: cannot call non-const method `<Filter<std::ops::Range<i32>, {closure@$DIR/typeck_type_placeholder_item.rs:240:29: 240:32}> as Iterator>::map::<i32, {closure@$DIR/typeck_type_placeholder_item.rs:240:49: 240:52}>` in constants
@@ -687,6 +699,13 @@ error[E0015]: cannot call non-const method `<Filter<std::ops::Range<i32>, {closu
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |                                             ^^^^^^^^^^^^^^
    |
+note: method `map` is not const because trait `Iterator` is not const
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+   |
+   = note: this trait is not const
+  ::: $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+   |
+   = note: this method is not const
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 83 previous errors