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/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_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 d59ac85ad05fc..ef5254cec0b0d 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_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/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/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index eeef94483fda0..9018079fb27de 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.
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 23b7727901147..f33c2439cd4d3 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/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`.