diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index c2233fa495a47..96fc9b2e37651 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -978,7 +978,7 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
                 }
             }
 
-            TerminatorKind::Goto { target: _ }
+            TerminatorKind::Goto { target: _, loop_hint_attrs: _ }
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Unreachable
             | TerminatorKind::UnwindResume
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index e4d1419b11d83..e10701e1a1b1c 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -195,7 +195,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
                     }
                 }
             }
-            TerminatorKind::Goto { target: _ }
+            TerminatorKind::Goto { target: _, loop_hint_attrs: _ }
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Unreachable
             | TerminatorKind::FalseEdge { real_target: _, imaginary_target: _ }
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index ab0d786c6f264..1dc4b29fb5187 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -2082,7 +2082,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     fn check_iscleanup(&mut self, block_data: &BasicBlockData<'tcx>) {
         let is_cleanup = block_data.is_cleanup;
         match block_data.terminator().kind {
-            TerminatorKind::Goto { target } => {
+            TerminatorKind::Goto { target, .. } => {
                 self.assert_iscleanup(block_data, target, is_cleanup)
             }
             TerminatorKind::SwitchInt { ref targets, .. } => {
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index e752189130290..a6d5e4c6a6423 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -343,7 +343,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
             crate::PrintOnPanic(|| format!("terminator {:?}", bb_data.terminator().kind));
 
         match &bb_data.terminator().kind {
-            TerminatorKind::Goto { target } => {
+            TerminatorKind::Goto { target, loop_hint_attrs: _ } => {
                 if let TerminatorKind::Return = fx.mir[*target].terminator().kind {
                     let mut can_immediately_return = true;
                     for stmt in &fx.mir[*target].statements {
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index b7c930502978e..d259fe83565fa 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -8,7 +8,7 @@ pub(crate) mod gpu_offload;
 
 use libc::{c_char, c_uint};
 use rustc_abi::{self as abi, Align, CanonAbi, Size, WrappingRange};
-use rustc_attr_ir::{AttributeKind, UnrollAttr};
+use rustc_attr_ir::UnrollAttr;
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::{IntPredicate, RealPredicate, SynchronizationScope, TypeKind};
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
@@ -340,16 +340,13 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn br_with_attrs(&mut self, dest: &'ll BasicBlock, loop_hint_attrs: &[AttributeKind]) {
+    fn br_with_attrs(&mut self, dest: &'ll BasicBlock, loop_hint_attrs: &[UnrollAttr]) {
         unsafe {
             let val = llvm::LLVMBuildBr(self.llbuilder, dest);
 
             let mut nodes = Vec::new();
 
-            for loop_hint_attr in loop_hint_attrs {
-                let AttributeKind::Unroll(unroll) = loop_hint_attr else {
-                    continue;
-                };
+            for unroll in loop_hint_attrs {
                 // UnrollAttr::Count needs a second operand, the provided count, but the other
                 // unroll hints do not.
                 let md_node = if let UnrollAttr::Count(count) = unroll {
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 9db1dd700e95e..2516a8d55ff8c 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -7,7 +7,7 @@ use rustc_abi::{
 };
 use rustc_ast as ast;
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
-use rustc_attr_ir::AttributeKind;
+use rustc_attr_ir::UnrollAttr;
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_data_structures::packed::Pu128;
 use rustc_lint_defs::builtin::TAIL_CALL_TRACK_CALLER;
@@ -140,7 +140,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
         bx: &mut Bx,
         target: mir::BasicBlock,
         mergeable_succ: bool,
-        loop_hint_attrs: &[AttributeKind],
+        loop_hint_attrs: &[UnrollAttr],
     ) -> MergingSucc {
         let (needs_landing_pad, is_cleanupret) = self.llbb_characteristics(fx, target);
         if mergeable_succ && !needs_landing_pad && !is_cleanupret {
@@ -1676,8 +1676,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 MergingSucc::False
             }
 
-            mir::TerminatorKind::Goto { target } => {
-                helper.funclet_br(self, bx, target, mergeable_succ(), &terminator.loop_hint_attrs)
+            mir::TerminatorKind::Goto { target, ref loop_hint_attrs } => {
+                helper.funclet_br(self, bx, target, mergeable_succ(), loop_hint_attrs)
             }
 
             mir::TerminatorKind::SwitchInt { ref discr, ref targets } => {
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index aefa8356536dc..433210d6c1d7f 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -437,7 +437,7 @@ fn optimize_use_clone<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 ))),
             ));
 
-            bb.terminator_mut().kind = mir::TerminatorKind::Goto { target: destination_block };
+            bb.terminator_mut().kind = mir::TerminatorKind::goto(destination_block);
         }
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 59e1f6e9d0098..3c0c01d07cccc 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -3,7 +3,7 @@ use std::ops::Deref;
 
 use rustc_abi::{Align, Scalar, Size, WrappingRange};
 use rustc_ast::expand::typetree::{FncTree, TypeTree};
-use rustc_attr_ir::AttributeKind;
+use rustc_attr_ir::UnrollAttr;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::mir;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
@@ -94,7 +94,7 @@ pub trait BuilderMethods<'a, 'tcx>:
     fn ret_void(&mut self);
     fn ret(&mut self, v: Self::Value);
     fn br(&mut self, dest: Self::BasicBlock);
-    fn br_with_attrs(&mut self, dest: Self::BasicBlock, _loop_hint_attrs: &[AttributeKind]) {
+    fn br_with_attrs(&mut self, dest: Self::BasicBlock, _loop_hint_attrs: &[UnrollAttr]) {
         self.br(dest)
     }
     fn cond_br(
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index e9f1d06187cd6..b647cc624bc04 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -532,7 +532,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.return_from_current_stack_frame(/* unwinding */ false)?
             }
 
-            Goto { target } => self.go_to_block(target),
+            Goto { target, loop_hint_attrs: _ } => self.go_to_block(target),
 
             SwitchInt { ref discr, ref targets } => {
                 let discr = self.read_immediate(&self.eval_operand(discr, None)?)?;
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 19a6d2a31c4e3..7dabc71e41b25 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -1732,11 +1732,11 @@ mod size_asserts {
 
     use super::*;
     // tidy-alphabetical-start
-    static_assert_size!(BasicBlockData<'_>, 144);
+    static_assert_size!(BasicBlockData<'_>, 136);
     static_assert_size!(LocalDecl<'_>, 40);
     static_assert_size!(SourceScopeData<'_>, 64);
     static_assert_size!(Statement<'_>, 40);
-    static_assert_size!(Terminator<'_>, 104);
+    static_assert_size!(Terminator<'_>, 96);
     static_assert_size!(VarDebugInfo<'_>, 88);
     // tidy-alphabetical-end
 }
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 6bb0190cd70b8..487c2c43da7d5 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -5,6 +5,7 @@
 
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece, Mutability};
+use rustc_attr_ir::UnrollAttr;
 use rustc_data_structures::packed::Pu128;
 use rustc_hir::CoroutineKind;
 use rustc_hir::def_id::DefId;
@@ -14,6 +15,7 @@ use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, Spanned, Symbol};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use smallvec::SmallVec;
+use thin_vec::ThinVec;
 
 use super::{BasicBlock, Const, Local, UserTypeProjection};
 use crate::mir::coverage::CoverageKind;
@@ -683,7 +685,7 @@ pub enum InlineAsmMacro {
 #[derive(Clone, TyEncodable, TyDecodable, StableHash, PartialEq, TypeFoldable, TypeVisitable)]
 pub enum TerminatorKind<'tcx> {
     /// Block has one successor; we continue execution there.
-    Goto { target: BasicBlock },
+    Goto { target: BasicBlock, loop_hint_attrs: ThinVec<UnrollAttr> },
 
     /// Switches based on the computed value.
     ///
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index 540a49aece678..c4e6a3089ae9b 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -3,7 +3,6 @@
 use std::slice;
 
 use rustc_ast::InlineAsmOptions;
-use rustc_attr_ir::AttributeKind;
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_data_structures::packed::Pu128;
 use rustc_macros::{StableHash, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
@@ -419,7 +418,6 @@ impl<O: fmt::Debug> fmt::Display for AssertKind<O> {
 pub struct Terminator<'tcx> {
     pub source_info: SourceInfo,
     pub kind: TerminatorKind<'tcx>,
-    pub loop_hint_attrs: ThinVec<AttributeKind>,
 }
 
 impl<'tcx> Terminator<'tcx> {
@@ -479,6 +477,11 @@ impl<'tcx> TerminatorKind<'tcx> {
     pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {
         TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }
     }
+
+    #[inline]
+    pub fn goto(target: BasicBlock) -> TerminatorKind<'tcx> {
+        TerminatorKind::Goto { target, loop_hint_attrs: ThinVec::new() }
+    }
 }
 
 pub use helper::*;
@@ -527,7 +530,7 @@ mod helper {
                     mk_successors(slice::from_ref(t), Some(u), None)
                 }
                 // single successor
-                Goto { target: ref t }
+                Goto { target: ref t, .. }
                 | Call { target: None, unwind: UnwindAction::Cleanup(ref t), .. }
                 | Call { target: Some(ref t), unwind: _, .. }
                 | Yield { resume: ref t, drop: None, .. }
@@ -590,7 +593,7 @@ mod helper {
                         f(u)
                     }
                 }
-                Goto { target } => {
+                Goto { target, .. } => {
                     f(target);
                 }
                 UnwindResume
@@ -675,7 +678,7 @@ impl<'tcx> TerminatorKind<'tcx> {
     #[inline]
     pub fn as_goto(&self) -> Option<BasicBlock> {
         match self {
-            TerminatorKind::Goto { target } => Some(*target),
+            TerminatorKind::Goto { target, loop_hint_attrs: _ } => Some(*target),
             _ => None,
         }
     }
@@ -745,7 +748,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             | CoroutineDrop
             | Unreachable => TerminatorEdges::None,
 
-            Goto { target } => TerminatorEdges::Single(target),
+            Goto { target, loop_hint_attrs: _ } => TerminatorEdges::Single(target),
 
             // FIXME: Maybe we need also TerminatorEdges::Trio for async drop
             // (target + unwind + dropline)
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 1b45378c86c0a..2bbe41bdad09f 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -518,7 +518,7 @@ macro_rules! make_mir_visitor {
                 terminator: &$($mutability)? Terminator<'tcx>,
                 location: Location
             ) {
-                let Terminator { source_info, kind, loop_hint_attrs: _ } = terminator;
+                let Terminator { source_info, kind } = terminator;
 
                 self.visit_source_info(source_info);
                 match kind {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index a3e5168e4f1e9..1205c5813a679 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -15,7 +15,7 @@ use std::sync::Arc;
 
 use rustc_abi::{FieldIdx, Integer, Size, VariantIdx};
 use rustc_ast::{AsmMacro, InlineAsmOptions, InlineAsmTemplatePiece, Mutability};
-use rustc_attr_ir::AttributeKind;
+use rustc_attr_ir::UnrollAttr;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
@@ -62,7 +62,7 @@ macro_rules! thir_with_elements {
         #[derive(Debug, StableHash, Clone)]
         pub struct Thir<'tcx> {
             pub body_type: BodyTy<'tcx>,
-            pub loop_hint_attrs: FxIndexMap<ExprId, ThinVec<AttributeKind>>,
+            pub loop_hint_attrs: FxIndexMap<ExprId, ThinVec<UnrollAttr>>,
             $(
                 pub $name: IndexVec<$id, $value>,
             )*
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 3710a159b3fdd..300c70e04ede6 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -218,6 +218,7 @@ TrivialTypeTraversalImpls! {
     rustc_ast::InlineAsmOptions,
     rustc_ast::InlineAsmTemplatePiece,
     rustc_attr_ir::AttributeKind,
+    rustc_attr_ir::UnrollAttr,
     rustc_hir::CoroutineKind,
     rustc_hir::HirId,
     rustc_hir::MatchSource,
diff --git a/compiler/rustc_mir_build/src/builder/cfg.rs b/compiler/rustc_mir_build/src/builder/cfg.rs
index a8e68963ec724..020858d427712 100644
--- a/compiler/rustc_mir_build/src/builder/cfg.rs
+++ b/compiler/rustc_mir_build/src/builder/cfg.rs
@@ -1,5 +1,6 @@
 //! Routines for manipulating the control-flow graph.
 
+use rustc_attr_ir::UnrollAttr;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
@@ -120,8 +121,7 @@ impl<'tcx> CFG<'tcx> {
             block,
             self.block_data(block)
         );
-        self.block_data_mut(block).terminator =
-            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() });
+        self.block_data_mut(block).terminator = Some(Terminator { source_info, kind });
         self.block_data_mut(block).terminator.as_mut().unwrap()
     }
 
@@ -132,6 +132,17 @@ impl<'tcx> CFG<'tcx> {
         source_info: SourceInfo,
         target: BasicBlock,
     ) -> &mut Terminator<'tcx> {
-        self.terminate(origin, source_info, TerminatorKind::Goto { target })
+        self.goto_with_hints(origin, source_info, target, ThinVec::new())
+    }
+
+    #[inline(always)]
+    pub(crate) fn goto_with_hints(
+        &mut self,
+        origin: BasicBlock,
+        source_info: SourceInfo,
+        target: BasicBlock,
+        loop_hint_attrs: ThinVec<UnrollAttr>,
+    ) -> &mut Terminator<'tcx> {
+        self.terminate(origin, source_info, TerminatorKind::Goto { target, loop_hint_attrs })
     }
 }
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse.rs b/compiler/rustc_mir_build/src/builder/custom/parse.rs
index 73ffbec6685cc..b227923292779 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse.rs
@@ -1,4 +1,3 @@
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::IndexSlice;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
@@ -319,7 +318,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
         data.terminator = Some(Terminator {
             source_info: SourceInfo { span, scope: self.source_scope },
             kind: terminator,
-            loop_hint_attrs: ThinVec::new(),
         });
 
         Ok(data)
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 5454a7bef67a7..3241e2b17ece5 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -47,7 +47,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                 Ok(TerminatorKind::Return)
             },
             @call(mir_goto, args) => {
-                Ok(TerminatorKind::Goto { target: self.parse_block(args[0])? } )
+                Ok(TerminatorKind::goto(self.parse_block(args[0])?))
             },
             @call(mir_unreachable, _args) => {
                 Ok(TerminatorKind::Unreachable)
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index 6ca12032362be..167bedfc2101e 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -4,6 +4,7 @@ use rustc_abi::FieldIdx;
 use rustc_ast::{AsmMacro, InlineAsmOptions};
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
@@ -237,10 +238,18 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     // Execute the body, branching back to the test.
                     let body_block_end = this.expr_into_dest(tmp, body_block, body).into_block();
 
-                    let goto = this.cfg.goto(body_block_end, source_info, loop_block);
-                    if let Some(attrs) = this.thir.loop_hint_attrs.get(&expr_id) {
-                        goto.loop_hint_attrs = attrs.clone();
-                    }
+                    let loop_hint_attrs = this
+                        .thir
+                        .loop_hint_attrs
+                        .get(&expr_id)
+                        .map(|attrs| attrs.clone())
+                        .unwrap_or_else(|| ThinVec::new());
+                    this.cfg.goto_with_hints(
+                        body_block_end,
+                        source_info,
+                        loop_block,
+                        loop_hint_attrs,
+                    );
 
                     // Loops are only exited by `break` expressions.
                     None
@@ -772,7 +781,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             this.cfg.terminate(
                                 target,
                                 source_info,
-                                TerminatorKind::Goto { target: destination_block },
+                                TerminatorKind::goto(destination_block),
                             );
 
                             mir::InlineAsmOperand::Label { target_index }
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index 4b3c224a84357..79505dd6f03fc 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -447,7 +447,7 @@ impl DropTree {
                         // use `DUMMY_SP`.
                         let source_info =
                             SourceInfo { span: DUMMY_SP, ..drop_node.data.source_info };
-                        let terminator = TerminatorKind::Goto { target };
+                        let terminator = TerminatorKind::goto(target);
                         cfg.terminate(block, source_info, terminator);
                     }
                 }
@@ -467,7 +467,7 @@ impl DropTree {
                         // use `DUMMY_SP`.
                         let source_info =
                             SourceInfo { span: DUMMY_SP, ..drop_node.data.source_info };
-                        let terminator = TerminatorKind::Goto { target };
+                        let terminator = TerminatorKind::goto(target);
                         cfg.terminate(block, source_info, terminator);
                     }
                 }
@@ -569,12 +569,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.cfg.terminate(
                     normal_block.into_block(),
                     source_info,
-                    TerminatorKind::Goto { target },
+                    TerminatorKind::goto(target),
                 );
                 self.cfg.terminate(
                     exit_block.into_block(),
                     source_info,
-                    TerminatorKind::Goto { target },
+                    TerminatorKind::goto(target),
                 );
                 target.unit()
             }
@@ -622,12 +622,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.cfg.terminate(
                     normal_block.into_block(),
                     source_info,
-                    TerminatorKind::Goto { target },
+                    TerminatorKind::goto(target),
                 );
                 self.cfg.terminate(
                     exit_block.into_block(),
                     source_info,
-                    TerminatorKind::Goto { target },
+                    TerminatorKind::goto(target),
                 );
                 target.unit()
             }
@@ -2117,7 +2117,7 @@ impl<'tcx> DropTreeBuilder<'tcx> for ExitScopes {
         // (The dummy is added by `break_scope` and `break_from_if_then_scope`.)
         let term = cfg.block_data_mut(from).terminator_mut();
         if let TerminatorKind::UnwindResume = term.kind {
-            term.kind = TerminatorKind::Goto { target: to };
+            term.kind = TerminatorKind::goto(to);
         } else {
             span_bug!(term.source_info.span, "unexpected dummy terminator kind: {:?}", term.kind);
         }
@@ -2158,7 +2158,7 @@ impl<'tcx> DropTreeBuilder<'tcx> for Unwind {
             TerminatorKind::Drop { unwind, .. } => {
                 if let UnwindAction::Cleanup(unwind) = *unwind {
                     let source_info = term.source_info;
-                    cfg.terminate(unwind, source_info, TerminatorKind::Goto { target: to });
+                    cfg.terminate(unwind, source_info, TerminatorKind::goto(to));
                 } else {
                     *unwind = UnwindAction::Cleanup(to);
                 }
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 16e92ae2c51e4..e38e9293ba196 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -2,7 +2,7 @@ use itertools::Itertools;
 use rustc_abi::{FIRST_VARIANT, FieldIdx, Size, VariantIdx};
 use rustc_ast::UnsafeBinderCastKind;
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_attr_ir::{AttributeKind, HasAttrs, find_attr};
+use rustc_attr_ir::{AttributeKind, HasAttrs, UnrollAttr, find_attr};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
 use rustc_hir::HirId;
@@ -57,13 +57,11 @@ impl<'tcx> SplattedFunc<'tcx> {
     }
 }
 
-fn filter_loop_hint_attrs(id: HirId, tcx: TyCtxt<'_>) -> ThinVec<AttributeKind> {
+fn filter_loop_hint_attrs(id: HirId, tcx: TyCtxt<'_>) -> ThinVec<UnrollAttr> {
     HasAttrs::get_attrs(id, &tcx)
         .into_iter()
         .filter_map(|attr| match attr {
-            rustc_attr_ir::Attribute::Parsed(attrkind @ AttributeKind::Unroll(_)) => {
-                Some(attrkind.clone())
-            }
+            rustc_attr_ir::Attribute::Parsed(AttributeKind::Unroll(unroll)) => Some(unroll.clone()),
             _ => None,
         })
         .collect()
diff --git a/compiler/rustc_mir_dataflow/src/framework/tests.rs b/compiler/rustc_mir_dataflow/src/framework/tests.rs
index 9646caab241d9..bfdf96a48f401 100644
--- a/compiler/rustc_mir_dataflow/src/framework/tests.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/tests.rs
@@ -2,7 +2,6 @@
 
 use std::marker::PhantomData;
 
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::IndexVec;
 use rustc_middle::ty;
 use rustc_span::DUMMY_SP;
@@ -22,7 +21,7 @@ fn mock_body<'tcx>() -> mir::Body<'tcx> {
 
         blocks.push(mir::BasicBlockData::new_stmts(
             std::iter::repeat(&nop).cloned().take(n).collect(),
-            Some(mir::Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
+            Some(mir::Terminator { source_info, kind }),
             false,
         ))
     };
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 3c1c631285f96..26628a05188d7 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -449,7 +449,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
     fn gather_terminator(&mut self, term: &Terminator<'tcx>) {
         debug!("gather_terminator({:?}, {:?})", self.loc, term);
         match term.kind {
-            TerminatorKind::Goto { target: _ }
+            TerminatorKind::Goto { target: _, .. }
             | TerminatorKind::FalseEdge { .. }
             | TerminatorKind::FalseUnwind { .. } => {}
             // In some sense returning moves the return place into the current
diff --git a/compiler/rustc_mir_transform/src/add_call_guards.rs b/compiler/rustc_mir_transform/src/add_call_guards.rs
index 01fd042864019..17e99f506e0f2 100644
--- a/compiler/rustc_mir_transform/src/add_call_guards.rs
+++ b/compiler/rustc_mir_transform/src/add_call_guards.rs
@@ -15,7 +15,6 @@
 //!
 //! NOTE: Simplify CFG will happily undo most of the work this pass does.
 
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
@@ -89,11 +88,7 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
         let cur_len = body.basic_blocks.len();
         let mut new_block = |source_info: SourceInfo, is_cleanup: bool, target: BasicBlock| {
             let block = BasicBlockData::new(
-                Some(Terminator {
-                    source_info,
-                    kind: TerminatorKind::Goto { target },
-                    loop_hint_attrs: ThinVec::new(),
-                }),
+                Some(Terminator { source_info, kind: TerminatorKind::goto(target) }),
                 is_cleanup,
             );
             let idx = cur_len + new_blocks.len();
diff --git a/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs b/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
index e0c07619efbc6..41c63d4857df8 100644
--- a/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
+++ b/compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
@@ -1,4 +1,3 @@
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, TyCtxt};
 use tracing::debug;
@@ -95,11 +94,7 @@ fn add_move_for_packed_drop<'tcx>(
 
     let storage_dead_block = patch.new_block(BasicBlockData::new_stmts(
         vec![Statement::new(source_info, StatementKind::StorageDead(temp))],
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Goto { target },
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::goto(target) }),
         is_cleanup,
     ));
 
diff --git a/compiler/rustc_mir_transform/src/check_enums.rs b/compiler/rustc_mir_transform/src/check_enums.rs
index 8d2178a07c5c6..260028c570461 100644
--- a/compiler/rustc_mir_transform/src/check_enums.rs
+++ b/compiler/rustc_mir_transform/src/check_enums.rs
@@ -1,6 +1,5 @@
 use rustc_abi::{Scalar, Size, TagEncoding, Variants, WrappingRange};
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::IndexVec;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::*;
@@ -63,8 +62,7 @@ impl<'tcx> crate::MirPass<'tcx> for CheckEnums {
                             );
                             basic_blocks[block].terminator = Some(Terminator {
                                 source_info,
-                                kind: TerminatorKind::Goto { target: new_block },
-                                loop_hint_attrs: ThinVec::new(),
+                                kind: TerminatorKind::goto(new_block),
                             });
                         }
                         EnumCheckType::Direct { source_op, discr, op_size, valid_discrs } => {
@@ -395,7 +393,6 @@ fn insert_direct_enum_check<'tcx>(
                 invalid_discr_block,
             ),
         },
-        loop_hint_attrs: ThinVec::new(),
     });
 
     // Abort in case of an invalid enum discriminant.
@@ -415,7 +412,6 @@ fn insert_direct_enum_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        loop_hint_attrs: ThinVec::new(),
     });
 }
 
@@ -461,7 +457,6 @@ fn insert_uninhabited_enum_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        loop_hint_attrs: ThinVec::new(),
     });
 }
 
@@ -539,6 +534,5 @@ fn insert_niche_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        loop_hint_attrs: ThinVec::new(),
     });
 }
diff --git a/compiler/rustc_mir_transform/src/check_pointers.rs b/compiler/rustc_mir_transform/src/check_pointers.rs
index fb6379a25af95..25336280926fe 100644
--- a/compiler/rustc_mir_transform/src/check_pointers.rs
+++ b/compiler/rustc_mir_transform/src/check_pointers.rs
@@ -1,5 +1,4 @@
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::IndexVec;
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
@@ -117,7 +116,6 @@ pub(crate) fn check_pointers<'tcx, F>(
                         // worse UB when we start unwinding.
                         unwind: UnwindAction::Unreachable,
                     },
-                    loop_hint_attrs: ThinVec::new(),
                 });
             }
         }
diff --git a/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs b/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
index 31d9d124ab846..6b7054302e77a 100644
--- a/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
+++ b/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
@@ -66,7 +66,7 @@ impl<'tcx> crate::MirPass<'tcx> for CleanupPostBorrowck {
                 TerminatorKind::FalseEdge { real_target, .. }
                 | TerminatorKind::FalseUnwind { real_target, .. } => {
                     invalidate_cfg = true;
-                    terminator.kind = TerminatorKind::Goto { target: real_target };
+                    terminator.kind = TerminatorKind::goto(real_target);
                 }
                 _ => {}
             }
diff --git a/compiler/rustc_mir_transform/src/coroutine/drop.rs b/compiler/rustc_mir_transform/src/coroutine/drop.rs
index 44ea6aef0e02d..aea2992bbce21 100644
--- a/compiler/rustc_mir_transform/src/coroutine/drop.rs
+++ b/compiler/rustc_mir_transform/src/coroutine/drop.rs
@@ -375,8 +375,7 @@ pub(super) fn create_coroutine_drop_shim_proxy_async<'tcx>(
         replace: false,
         drop: None,
     };
-    body.basic_blocks_mut()[call_bb].terminator =
-        Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() });
+    body.basic_blocks_mut()[call_bb].terminator = Some(Terminator { source_info, kind });
 
     // Run derefer to fix Derefs that are not in the first place
     deref_finder(tcx, &mut body, false);
diff --git a/compiler/rustc_mir_transform/src/coroutine/mod.rs b/compiler/rustc_mir_transform/src/coroutine/mod.rs
index 1e63dca78adbb..ba75c8934272d 100644
--- a/compiler/rustc_mir_transform/src/coroutine/mod.rs
+++ b/compiler/rustc_mir_transform/src/coroutine/mod.rs
@@ -64,7 +64,6 @@ pub(super) use layout::mir_coroutine_witnesses;
 use layout::{CoroutineSavedLocals, compute_layout, locals_live_across_suspend_points};
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::{self as hir, CoroutineDesugaring, CoroutineKind};
 use rustc_index::bit_set::{BitMatrix, DenseBitSet};
 use rustc_index::{Idx, IndexVec, indexvec};
@@ -253,11 +252,7 @@ impl<'tcx> TransformVisitor<'tcx> {
 
         body.basic_blocks_mut().push(BasicBlockData::new_stmts(
             statements,
-            Some(Terminator {
-                source_info,
-                kind: TerminatorKind::Return,
-                loop_hint_attrs: ThinVec::new(),
-            }),
+            Some(Terminator { source_info, kind: TerminatorKind::Return }),
             false,
         ));
 
@@ -698,7 +693,7 @@ fn eliminate_get_context_calls<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
                 terminator.source_info,
                 StatementKind::Assign(Box::new((*destination, arg))),
             );
-            terminator.kind = TerminatorKind::Goto { target: target.unwrap() };
+            terminator.kind = TerminatorKind::goto(target.unwrap());
             bb_data.statements.push(assign);
         }
     }
@@ -741,19 +736,13 @@ fn insert_switch<'tcx>(
     }
 
     let switch = TerminatorKind::SwitchInt { discr: Operand::Move(discr), targets: switch_targets };
-    body.basic_blocks_mut()[START_BLOCK].terminator = Some(Terminator {
-        source_info: SourceInfo::outermost(body.span),
-        kind: switch,
-        loop_hint_attrs: ThinVec::new(),
-    });
+    body.basic_blocks_mut()[START_BLOCK].terminator =
+        Some(Terminator { source_info: SourceInfo::outermost(body.span), kind: switch });
 }
 
 fn insert_term_block<'tcx>(body: &mut Body<'tcx>, kind: TerminatorKind<'tcx>) -> BasicBlock {
     let source_info = SourceInfo::outermost(body.span);
-    body.basic_blocks_mut().push(BasicBlockData::new(
-        Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
-        false,
-    ))
+    body.basic_blocks_mut().push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
 }
 
 fn return_poll_ready_assign<'tcx>(tcx: TyCtxt<'tcx>, source_info: SourceInfo) -> Statement<'tcx> {
@@ -776,11 +765,7 @@ fn insert_poll_ready_block<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> Ba
     let source_info = SourceInfo::outermost(body.span);
     body.basic_blocks_mut().push(BasicBlockData::new_stmts(
         [return_poll_ready_assign(tcx, source_info)].to_vec(),
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     ))
 }
@@ -835,12 +820,7 @@ fn generate_poison_block_and_redirect_unwinds_there<'tcx>(
     let source_info = SourceInfo::outermost(body.span);
     let poison_block = body.basic_blocks_mut().push(BasicBlockData::new_stmts(
         vec![transform.set_discr(VariantIdx::new(CoroutineArgs::POISONED), source_info)],
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::UnwindResume,
-
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::UnwindResume }),
         true,
     ));
 
@@ -851,12 +831,8 @@ fn generate_poison_block_and_redirect_unwinds_there<'tcx>(
             // An existing `Resume` terminator is redirected to jump to our dedicated
             // "poisoning block" above.
             if idx != poison_block {
-                *block.terminator_mut() = Terminator {
-                    source_info,
-                    kind: TerminatorKind::Goto { target: poison_block },
-
-                    loop_hint_attrs: ThinVec::new(),
-                };
+                *block.terminator_mut() =
+                    Terminator { source_info, kind: TerminatorKind::goto(poison_block) };
             }
         } else if !block.is_cleanup
             // Any terminators that *can* unwind but don't have an unwind target set are also
@@ -1019,12 +995,7 @@ fn create_cases<'tcx>(
                 // Then jump to the real target
                 let block = body.basic_blocks_mut().push(BasicBlockData::new_stmts(
                     statements,
-                    Some(Terminator {
-                        source_info,
-                        kind: TerminatorKind::Goto { target },
-
-                        loop_hint_attrs: ThinVec::new(),
-                    }),
+                    Some(Terminator { source_info, kind: TerminatorKind::goto(target) }),
                     false,
                 ));
 
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
index dcc7c5b91d76a..2a5eae62f80ec 100644
--- a/compiler/rustc_mir_transform/src/coverage/graph.rs
+++ b/compiler/rustc_mir_transform/src/coverage/graph.rs
@@ -381,7 +381,7 @@ fn bcb_filtered_successors<'a, 'tcx>(terminator: &'a Terminator<'tcx>) -> Covera
         | Drop { target, .. }
         | FalseEdge { real_target: target, .. }
         | FalseUnwind { real_target: target, .. }
-        | Goto { target } => slice::from_ref(target),
+        | Goto { target, .. } => slice::from_ref(target),
 
         // A call terminator can normally be chained, except when it has no
         // successor because it is known to diverge.
diff --git a/compiler/rustc_mir_transform/src/coverage/tests.rs b/compiler/rustc_mir_transform/src/coverage/tests.rs
index e9876310f112f..9fcd2a3028f84 100644
--- a/compiler/rustc_mir_transform/src/coverage/tests.rs
+++ b/compiler/rustc_mir_transform/src/coverage/tests.rs
@@ -26,7 +26,6 @@
 
 use itertools::Itertools;
 use rustc_data_structures::graph::{DirectedGraph, Successors};
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::mir::*;
 use rustc_middle::ty;
@@ -73,7 +72,6 @@ impl<'tcx> MockBlocks<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(Span::with_root_ctxt(next_lo, next_hi)),
                 kind,
-                loop_hint_attrs: ThinVec::new(),
             }),
             false,
         ))
@@ -86,7 +84,7 @@ impl<'tcx> MockBlocks<'tcx> {
             | TerminatorKind::Drop { ref mut target, .. }
             | TerminatorKind::FalseEdge { real_target: ref mut target, .. }
             | TerminatorKind::FalseUnwind { real_target: ref mut target, .. }
-            | TerminatorKind::Goto { ref mut target }
+            | TerminatorKind::Goto { ref mut target, .. }
             | TerminatorKind::Yield { resume: ref mut target, .. } => *target = to_block,
             ref invalid => bug!("Invalid from_block: {:?}", invalid),
         }
@@ -145,7 +143,7 @@ impl<'tcx> MockBlocks<'tcx> {
     }
 
     fn goto(&mut self, some_from_block: Option<BasicBlock>) -> BasicBlock {
-        self.add_block_from(some_from_block, TerminatorKind::Goto { target: TEMP_BLOCK })
+        self.add_block_from(some_from_block, TerminatorKind::goto(TEMP_BLOCK))
     }
 
     fn switchint(&mut self, some_from_block: Option<BasicBlock>) -> BasicBlock {
@@ -182,7 +180,7 @@ fn debug_basic_blocks(mir_body: &Body<'_>) -> String {
                     | TerminatorKind::Drop { target, .. }
                     | TerminatorKind::FalseEdge { real_target: target, .. }
                     | TerminatorKind::FalseUnwind { real_target: target, .. }
-                    | TerminatorKind::Goto { target }
+                    | TerminatorKind::Goto { target, .. }
                     | TerminatorKind::Yield { resume: target, .. } => {
                         format!("{}{:?}:{} -> {:?}", sp, bb, kind.name(), target)
                     }
diff --git a/compiler/rustc_mir_transform/src/early_otherwise_branch.rs b/compiler/rustc_mir_transform/src/early_otherwise_branch.rs
index b1ac4d33445b0..6a34f0167354b 100644
--- a/compiler/rustc_mir_transform/src/early_otherwise_branch.rs
+++ b/compiler/rustc_mir_transform/src/early_otherwise_branch.rs
@@ -1,6 +1,5 @@
 use std::fmt::Debug;
 
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{Ty, TyCtxt};
 use tracing::trace;
@@ -175,7 +174,6 @@ impl<'tcx> crate::MirPass<'tcx> for EarlyOtherwiseBranch {
                         discr: parent_op,
                         targets: eq_targets,
                     },
-                    loop_hint_attrs: ThinVec::new(),
                 }),
                 bbs[parent].is_cleanup,
             );
@@ -230,7 +228,6 @@ fn evaluate_candidate<'tcx>(
     let Terminator {
         kind: TerminatorKind::SwitchInt { targets: child_targets, discr: child_discr },
         source_info,
-        loop_hint_attrs: _,
     } = bbs[child].terminator()
     else {
         return None;
diff --git a/compiler/rustc_mir_transform/src/elaborate_drop.rs b/compiler/rustc_mir_transform/src/elaborate_drop.rs
index 9b81f55ab1145..db8d5d6fd23b9 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drop.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drop.rs
@@ -3,7 +3,6 @@ use std::{fmt, iter, mem};
 use itertools::Itertools;
 use rustc_abi::{FIRST_VARIANT, FieldIdx, VariantIdx};
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::{CoroutineDesugaring, CoroutineKind};
 use rustc_index::Idx;
 use rustc_middle::mir::*;
@@ -263,20 +262,20 @@ where
         let succ_with_dead = self.new_block_with_statements(
             unwind,
             vec![self.storage_dead(fut)],
-            TerminatorKind::Goto { target: succ },
+            TerminatorKind::goto(succ),
         );
         let dropline_with_dead = dropline.map(|target| {
             self.new_block_with_statements(
                 unwind,
                 vec![self.storage_dead(fut)],
-                TerminatorKind::Goto { target },
+                TerminatorKind::goto(target),
             )
         });
         let unwind_with_dead = unwind.map(|target| {
             self.new_block_with_statements(
                 Unwind::InCleanup,
                 vec![self.storage_dead(fut)],
-                TerminatorKind::Goto { target },
+                TerminatorKind::goto(target),
             )
         });
 
@@ -322,12 +321,8 @@ where
             dropline_with_dead.unwrap_or(succ_with_dead),
             unwind_with_dead,
         );
-        self.elaborator
-            .patch()
-            .patch_terminator(drop_resume_bb, TerminatorKind::Goto { target: panic_bb });
-        self.elaborator
-            .patch()
-            .patch_terminator(drop_drop_bb, TerminatorKind::Goto { target: drop_pin_bb });
+        self.elaborator.patch().patch_terminator(drop_resume_bb, TerminatorKind::goto(panic_bb));
+        self.elaborator.patch().patch_terminator(drop_drop_bb, TerminatorKind::goto(drop_pin_bb));
 
         // If we are in the regular code path, `dropline_with_dead` is `Some`.
         //
@@ -344,12 +339,8 @@ where
                 succ_with_dead,
                 unwind_with_dead,
             );
-            self.elaborator
-                .patch()
-                .patch_terminator(resume_bb, TerminatorKind::Goto { target: pin_bb });
-            self.elaborator
-                .patch()
-                .patch_terminator(drop_bb, TerminatorKind::Goto { target: drop_pin_bb });
+            self.elaborator.patch().patch_terminator(resume_bb, TerminatorKind::goto(pin_bb));
+            self.elaborator.patch().patch_terminator(drop_bb, TerminatorKind::goto(drop_pin_bb));
             pin_bb
         } else {
             // We were already in the drop line, so return the loop we created for it.
@@ -654,9 +645,7 @@ where
                 self.dropline,
                 false,
             );
-            self.elaborator
-                .patch()
-                .patch_terminator(bb, TerminatorKind::Goto { target: async_drop_bb });
+            self.elaborator.patch().patch_terminator(bb, TerminatorKind::goto(async_drop_bb));
         } else {
             self.elaborator.patch().patch_terminator(
                 bb,
@@ -745,24 +734,18 @@ where
     fn elaborate_drop(&mut self, bb: BasicBlock) {
         match self.elaborator.drop_style(self.path, DropFlagMode::Deep) {
             DropStyle::Dead => {
-                self.elaborator
-                    .patch()
-                    .patch_terminator(bb, TerminatorKind::Goto { target: self.succ });
+                self.elaborator.patch().patch_terminator(bb, TerminatorKind::goto(self.succ));
             }
             DropStyle::Static => {
                 self.build_drop(bb);
             }
             DropStyle::Conditional => {
                 let drop_bb = self.complete_drop(self.succ, self.unwind);
-                self.elaborator
-                    .patch()
-                    .patch_terminator(bb, TerminatorKind::Goto { target: drop_bb });
+                self.elaborator.patch().patch_terminator(bb, TerminatorKind::goto(drop_bb));
             }
             DropStyle::Open => {
                 let drop_bb = self.open_drop();
-                self.elaborator
-                    .patch()
-                    .patch_terminator(bb, TerminatorKind::Goto { target: drop_bb });
+                self.elaborator.patch().patch_terminator(bb, TerminatorKind::goto(drop_bb));
             }
         }
     }
@@ -1023,7 +1006,7 @@ where
                 Place::from(ptr_local),
                 Rvalue::Cast(CastKind::Transmute, Operand::Copy(nonnull_place), ptr_ty),
             )],
-            TerminatorKind::Goto { target: do_drop_bb },
+            TerminatorKind::goto(do_drop_bb),
         )
     }
 
@@ -1335,7 +1318,7 @@ where
                 self.build_async_drop(place, ety, loop_block, unwind, dropline, false);
             self.elaborator
                 .patch()
-                .patch_terminator(drop_block, TerminatorKind::Goto { target: async_drop_bb });
+                .patch_terminator(drop_block, TerminatorKind::goto(async_drop_bb));
         } else {
             self.elaborator.patch().patch_terminator(
                 drop_block,
@@ -1449,7 +1432,7 @@ where
                     ),
                 ),
             ],
-            TerminatorKind::Goto { target: slice_block },
+            TerminatorKind::goto(slice_block),
         )
     }
 
@@ -1491,7 +1474,7 @@ where
                 ),
                 self.assign(cur.into(), Rvalue::Use(zero, WithRetag::Yes)),
             ],
-            TerminatorKind::Goto { target: loop_block },
+            TerminatorKind::goto(loop_block),
         );
 
         // FIXME(#34708): handle partially-dropped array/slice elements.
@@ -1577,7 +1560,7 @@ where
         if statements.is_empty() {
             return succ;
         }
-        self.new_block_with_statements(unwind, statements, TerminatorKind::Goto { target: succ })
+        self.new_block_with_statements(unwind, statements, TerminatorKind::goto(succ))
     }
 
     #[instrument(level = "debug", skip(self), ret)]
@@ -1641,11 +1624,7 @@ where
     #[instrument(level = "trace", skip(self), ret)]
     fn new_block(&mut self, unwind: Unwind, k: TerminatorKind<'tcx>) -> BasicBlock {
         self.elaborator.patch().new_block(BasicBlockData::new(
-            Some(Terminator {
-                source_info: self.source_info,
-                kind: k,
-                loop_hint_attrs: ThinVec::new(),
-            }),
+            Some(Terminator { source_info: self.source_info, kind: k }),
             unwind.is_cleanup(),
         ))
     }
@@ -1659,11 +1638,7 @@ where
     ) -> BasicBlock {
         self.elaborator.patch().new_block(BasicBlockData::new_stmts(
             statements,
-            Some(Terminator {
-                source_info: self.source_info,
-                kind: k,
-                loop_hint_attrs: ThinVec::new(),
-            }),
+            Some(Terminator { source_info: self.source_info, kind: k }),
             unwind.is_cleanup(),
         ))
     }
diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index a19ae86542d25..3c4e1d698804a 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -352,7 +352,7 @@ impl<'a, 'tcx> ElaborateDropsCtxt<'a, 'tcx> {
                 .ty
                 .needs_drop(self.tcx, self.typing_env())
             {
-                self.patch.patch_terminator(bb, TerminatorKind::Goto { target });
+                self.patch.patch_terminator(bb, TerminatorKind::goto(target));
                 continue;
             }
 
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 38021f4b76a4d..367e16daa8232 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -6,7 +6,6 @@ use std::{debug_assert_matches, iter};
 use rustc_abi::{ExternAbi, FieldIdx};
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_attr_ir::{InlineAttr, OptimizeAttr};
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_index::Idx;
@@ -871,8 +870,7 @@ fn inline_call<'tcx, I: Inliner<'tcx>>(
         let data = BasicBlockData::new(
             Some(Terminator {
                 source_info: terminator.source_info,
-                kind: TerminatorKind::Goto { target: block },
-                loop_hint_attrs: ThinVec::new(),
+                kind: TerminatorKind::goto(block),
             }),
             caller_body[block].is_cleanup,
         );
@@ -999,8 +997,7 @@ fn inline_call<'tcx, I: Inliner<'tcx>>(
 
     caller_body[callsite.block].terminator = Some(Terminator {
         source_info: callsite.source_info,
-        kind: TerminatorKind::Goto { target: integrator.map_block(START_BLOCK) },
-        loop_hint_attrs: ThinVec::new(),
+        kind: TerminatorKind::goto(integrator.map_block(START_BLOCK)),
     });
 
     // Copy required constants from the callee_body into the caller_body. Although we are only
@@ -1285,7 +1282,7 @@ impl<'tcx> MutVisitor<'tcx> for Integrator<'_, 'tcx> {
 
         match terminator.kind {
             TerminatorKind::CoroutineDrop | TerminatorKind::Yield { .. } => bug!(),
-            TerminatorKind::Goto { ref mut target } => {
+            TerminatorKind::Goto { ref mut target, .. } => {
                 *target = self.map_block(*target);
             }
             TerminatorKind::SwitchInt { ref mut targets, .. } => {
@@ -1313,14 +1310,14 @@ impl<'tcx> MutVisitor<'tcx> for Integrator<'_, 'tcx> {
             }
             TerminatorKind::Return => {
                 terminator.kind = if let Some(tgt) = self.return_block {
-                    TerminatorKind::Goto { target: tgt }
+                    TerminatorKind::goto(tgt)
                 } else {
                     TerminatorKind::Unreachable
                 }
             }
             TerminatorKind::UnwindResume => {
                 terminator.kind = match self.cleanup_block {
-                    UnwindAction::Cleanup(tgt) => TerminatorKind::Goto { target: tgt },
+                    UnwindAction::Cleanup(tgt) => TerminatorKind::goto(tgt),
                     UnwindAction::Continue => TerminatorKind::UnwindResume,
                     UnwindAction::Unreachable => TerminatorKind::Unreachable,
                     UnwindAction::Terminate(reason) => TerminatorKind::UnwindTerminate(reason),
diff --git a/compiler/rustc_mir_transform/src/instsimplify.rs b/compiler/rustc_mir_transform/src/instsimplify.rs
index e02e29a2e23e0..eaedb7c9aca3d 100644
--- a/compiler/rustc_mir_transform/src/instsimplify.rs
+++ b/compiler/rustc_mir_transform/src/instsimplify.rs
@@ -256,7 +256,7 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
                 ),
             ))),
         ));
-        terminator.kind = TerminatorKind::Goto { target: *destination_block };
+        terminator.kind = TerminatorKind::goto(*destination_block);
     }
 
     /// Simplify `size_of_val` and `align_of_val` if we don't actually need
@@ -314,7 +314,7 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
                     Rvalue::Use(const_op, WithRetag::Yes),
                 ))),
             ));
-            terminator.kind = TerminatorKind::Goto { target: *destination_block };
+            terminator.kind = TerminatorKind::goto(*destination_block);
         }
     }
 
@@ -371,7 +371,7 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
                     Rvalue::BinaryOp(BinOp::Eq, Box::new((lhs_op, rhs_op))),
                 ))),
             ));
-            terminator.kind = TerminatorKind::Goto { target: *destination_block };
+            terminator.kind = TerminatorKind::goto(*destination_block);
         }
     }
 
@@ -421,7 +421,7 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
             }
             Some(false) => {
                 // If we know the assert does not panic, turn the call into a Goto
-                terminator.kind = TerminatorKind::Goto { target: target_block };
+                terminator.kind = TerminatorKind::goto(target_block);
             }
         }
     }
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index 05616da42505b..ef92a373d5a46 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -1049,7 +1049,7 @@ impl<'a, 'tcx> OpportunitySet<'a, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     fn apply_goto(&mut self, bb: BasicBlock, target: BasicBlock) {
-        self.basic_blocks[bb].terminator_mut().kind = TerminatorKind::Goto { target };
+        self.basic_blocks[bb].terminator_mut().kind = TerminatorKind::goto(target);
     }
 
     #[instrument(level = "debug", skip(self), ret)]
diff --git a/compiler/rustc_mir_transform/src/lint_and_remove_uninhabited.rs b/compiler/rustc_mir_transform/src/lint_and_remove_uninhabited.rs
index 458be599c3fea..6e875902be506 100644
--- a/compiler/rustc_mir_transform/src/lint_and_remove_uninhabited.rs
+++ b/compiler/rustc_mir_transform/src/lint_and_remove_uninhabited.rs
@@ -126,7 +126,7 @@ fn find_unreachable_code_from<'tcx>(
     match term.kind {
         // The user does not care for `goto` and compiler-generated drops. If the target block is
         // only reachable through those terminators, continue searching there.
-        TerminatorKind::Goto { target } | TerminatorKind::Drop { target, .. } => {
+        TerminatorKind::Goto { target, .. } | TerminatorKind::Drop { target, .. } => {
             if &body.basic_blocks.predecessors()[target][..] == &[bb] {
                 find_unreachable_code_from(target, body)
             } else {
diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
index 7725daa276cc6..1ec81d0d73b21 100644
--- a/compiler/rustc_mir_transform/src/liveness.rs
+++ b/compiler/rustc_mir_transform/src/liveness.rs
@@ -120,7 +120,7 @@ pub(crate) fn check_liveness<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Den
                 if let TerminatorKind::Return | TerminatorKind::UnwindResume =
                     bbdata.terminator().kind
                 {
-                    bbdata.terminator_mut().kind = TerminatorKind::Goto { target: START_BLOCK };
+                    bbdata.terminator_mut().kind = TerminatorKind::goto(START_BLOCK);
                 }
             }
             body = &body_mem;
@@ -1418,7 +1418,7 @@ impl<'tcx> Visitor<'tcx> for TransferFunction<'_, 'tcx> {
         match terminator.kind {
             TerminatorKind::Return
             | TerminatorKind::Yield { .. }
-            | TerminatorKind::Goto { target: START_BLOCK } // Inserted for the `FnMut` case.
+            | TerminatorKind::Goto { target: START_BLOCK, .. } // Inserted for the `FnMut` case.
             | TerminatorKind::Call { target: None, .. } // unwinding could be caught
                 if self.capture_kind != CaptureKind::None =>
             {
diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
index c0f906330d8af..3ee8c405a1d77 100644
--- a/compiler/rustc_mir_transform/src/lower_intrinsics.rs
+++ b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
@@ -38,7 +38,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::Use(Operand::RuntimeChecks(op), WithRetag::Yes),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::forget => {
                         let target = target.unwrap();
@@ -56,7 +56,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 ),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::copy_nonoverlapping => {
                         let target = target.unwrap();
@@ -75,7 +75,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 ),
                             )),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::assume => {
                         let target = target.unwrap();
@@ -88,7 +88,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 arg.node,
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::wrapping_add
                     | sym::wrapping_sub
@@ -126,7 +126,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::BinaryOp(bin_op, Box::new((lhs.node, rhs.node))),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::add_with_overflow | sym::sub_with_overflow | sym::mul_with_overflow => {
                         let target = target.unwrap();
@@ -146,7 +146,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::BinaryOp(bin_op, Box::new((lhs.node, rhs.node))),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::read_via_copy => {
                         let Ok([arg]) = take_array(args) else {
@@ -177,7 +177,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 // so it must be unreachable.
                                 TerminatorKind::Unreachable
                             }
-                            Some(target) => TerminatorKind::Goto { target },
+                            Some(target) => TerminatorKind::goto(target),
                         }
                     }
                     // `write_via_move` is already lowered during MIR building.
@@ -198,7 +198,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::Discriminant(arg),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::offset => {
                         let target = target.unwrap();
@@ -215,7 +215,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::BinaryOp(BinOp::Offset, Box::new((ptr.node, delta.node))),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::slice_get_unchecked => {
                         let target = target.unwrap();
@@ -261,7 +261,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                             terminator.source_info,
                             StatementKind::Assign(Box::new((*destination, rvalue))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::transmute | sym::transmute_unchecked => {
                         let dst_ty = destination.ty(local_decls, tcx).ty;
@@ -283,7 +283,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                             ))),
                         ));
                         if let Some(target) = *target {
-                            terminator.kind = TerminatorKind::Goto { target };
+                            terminator.kind = TerminatorKind::goto(target);
                         } else {
                             terminator.kind = TerminatorKind::Unreachable;
                         }
@@ -313,7 +313,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::Aggregate(Box::new(kind), fields.into()),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     sym::ptr_metadata => {
                         let Ok([ptr]) = take_array(args) else {
@@ -330,7 +330,7 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                                 Rvalue::UnaryOp(UnOp::PtrMetadata, ptr.node),
                             ))),
                         ));
-                        terminator.kind = TerminatorKind::Goto { target };
+                        terminator.kind = TerminatorKind::goto(target);
                     }
                     _ => {}
                 }
diff --git a/compiler/rustc_mir_transform/src/lower_slice_len.rs b/compiler/rustc_mir_transform/src/lower_slice_len.rs
index 1dfba7d6c5200..745ced538c8e7 100644
--- a/compiler/rustc_mir_transform/src/lower_slice_len.rs
+++ b/compiler/rustc_mir_transform/src/lower_slice_len.rs
@@ -57,7 +57,7 @@ fn lower_slice_len_call<'tcx>(block: &mut BasicBlockData<'tcx>, slice_len_fn_ite
         let add_statement = Statement::new(terminator.source_info, len_statement_kind);
 
         // modify terminator into simple Goto
-        let new_terminator_kind = TerminatorKind::Goto { target: *bb };
+        let new_terminator_kind = TerminatorKind::goto(*bb);
 
         block.statements.push(add_statement);
         block.terminator_mut().kind = new_terminator_kind;
diff --git a/compiler/rustc_mir_transform/src/multiple_return_terminators.rs b/compiler/rustc_mir_transform/src/multiple_return_terminators.rs
index 280a57e474237..5df08eb7ad52f 100644
--- a/compiler/rustc_mir_transform/src/multiple_return_terminators.rs
+++ b/compiler/rustc_mir_transform/src/multiple_return_terminators.rs
@@ -25,7 +25,7 @@ impl<'tcx> crate::MirPass<'tcx> for MultipleReturnTerminators {
         }
 
         for bb in bbs {
-            if let TerminatorKind::Goto { target } = bb.terminator().kind
+            if let TerminatorKind::Goto { target, .. } = bb.terminator().kind
                 && bbs_simple_returns.contains(target)
             {
                 bb.terminator_mut().kind = TerminatorKind::Return;
diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index 6a2d5101067e7..da1077707baff 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -1,5 +1,4 @@
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_index::Idx;
 use rustc_middle::mir::*;
 use rustc_middle::ty::Ty;
@@ -93,7 +92,6 @@ impl<'tcx> MirPatch<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(self.body_span),
                 kind: TerminatorKind::UnwindResume,
-                loop_hint_attrs: ThinVec::new(),
             }),
             true,
         ));
@@ -110,7 +108,6 @@ impl<'tcx> MirPatch<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(self.body_span),
                 kind: TerminatorKind::Unreachable,
-                loop_hint_attrs: ThinVec::new(),
             }),
             true,
         ));
@@ -127,7 +124,6 @@ impl<'tcx> MirPatch<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(self.body_span),
                 kind: TerminatorKind::Unreachable,
-                loop_hint_attrs: ThinVec::new(),
             }),
             false,
         ));
@@ -146,7 +142,6 @@ impl<'tcx> MirPatch<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(self.body_span),
                 kind: TerminatorKind::UnwindTerminate(reason),
-                loop_hint_attrs: ThinVec::new(),
             }),
             true,
         ));
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 92c2f9a1c20e1..b490ebb3a9392 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -16,7 +16,6 @@ use std::{assert_matches, cmp, iter, mem};
 use either::{Left, Right};
 use rustc_const_eval::check_consts::{ConstCx, qualifs};
 use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_index::{IndexSlice, IndexVec};
@@ -611,7 +610,7 @@ impl<'tcx> Validator<'_, 'tcx> {
             safe_blocks.insert(safe_block);
             // Let's see if we can find another safe block.
             safe_block = match body.basic_blocks[safe_block].terminator().kind {
-                TerminatorKind::Goto { target } => target,
+                TerminatorKind::Goto { target, .. } => target,
                 TerminatorKind::Call { target: Some(target), .. }
                 | TerminatorKind::Drop { target, .. } => {
                     // This calls a function or the destructor. `target` does not get executed if
@@ -757,7 +756,6 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(span),
                 kind: TerminatorKind::Return,
-                loop_hint_attrs: ThinVec::new(),
             }),
             false,
         ))
@@ -845,8 +843,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                 };
                 Terminator {
                     source_info: terminator.source_info,
-                    kind: mem::replace(&mut terminator.kind, TerminatorKind::Goto { target }),
-                    loop_hint_attrs: ThinVec::new(),
+                    kind: mem::replace(&mut terminator.kind, TerminatorKind::goto(target)),
                 }
             };
 
@@ -1099,7 +1096,7 @@ fn promote_candidates<'tcx>(
             && let Some(index) = place.as_local()
         {
             if promoted(index) {
-                terminator.kind = TerminatorKind::Goto { target: *target };
+                terminator.kind = TerminatorKind::goto(*target);
             }
         }
     }
diff --git a/compiler/rustc_mir_transform/src/remove_uninit_drops.rs b/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
index c5f462f714dd8..74cac4c8481f0 100644
--- a/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
+++ b/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
@@ -62,7 +62,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveUninitDrops {
             };
 
             // Replace block terminator with `Goto`.
-            block.terminator_mut().kind = TerminatorKind::Goto { target: *target };
+            block.terminator_mut().kind = TerminatorKind::goto(*target);
         }
     }
 
diff --git a/compiler/rustc_mir_transform/src/remove_unneeded_drops.rs b/compiler/rustc_mir_transform/src/remove_unneeded_drops.rs
index 45a5c5626f98a..04c9204aa6aa5 100644
--- a/compiler/rustc_mir_transform/src/remove_unneeded_drops.rs
+++ b/compiler/rustc_mir_transform/src/remove_unneeded_drops.rs
@@ -29,7 +29,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveUnneededDrops {
                 continue;
             }
             debug!("SUCCESS: replacing `drop` with goto({:?})", target);
-            terminator.kind = TerminatorKind::Goto { target };
+            terminator.kind = TerminatorKind::goto(target);
             should_simplify = true;
         }
 
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index faf7039d498b1..f1d85166653ff 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -2,7 +2,6 @@ use std::{assert_matches, fmt, iter};
 
 use rustc_abi::{ExternAbi, FIRST_VARIANT, FieldIdx, VariantIdx};
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_index::{Idx, IndexVec};
@@ -280,13 +279,10 @@ pub fn build_drop_shim<'tcx>(
     let return_block = BasicBlock::new(1);
     let mut blocks = IndexVec::with_capacity(2);
     let block = |blocks: &mut IndexVec<_, _>, kind| {
-        blocks.push(BasicBlockData::new(
-            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
-            false,
-        ))
+        blocks.push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
     };
     if ty.is_some() {
-        block(&mut blocks, TerminatorKind::Goto { target: return_block });
+        block(&mut blocks, TerminatorKind::goto(return_block));
     }
     block(&mut blocks, TerminatorKind::Return);
 
@@ -338,7 +334,6 @@ pub fn build_drop_shim<'tcx>(
                 call_source: CallSource::Misc,
                 fn_span: span,
             },
-            loop_hint_attrs: ThinVec::new(),
         });
     } else {
         let patch = {
@@ -491,11 +486,7 @@ fn build_thread_local_shim<'tcx>(tcx: TyCtxt<'tcx>, shim: ty::ShimKind<'tcx>) ->
                 Rvalue::ThreadLocalRef(def_id),
             ))),
         )],
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     )]);
 
@@ -581,7 +572,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
         let source_info = self.source_info();
         self.blocks.push(BasicBlockData::new_stmts(
             statements,
-            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
+            Some(Terminator { source_info, kind }),
             is_cleanup,
         ))
     }
@@ -704,7 +695,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
             unwind = next_unwind;
         }
         // If all clones succeed then we end up here.
-        self.block(vec![], TerminatorKind::Goto { target }, false);
+        self.block(vec![], TerminatorKind::goto(target), false);
         unwind
     }
 
@@ -712,7 +703,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
     where
         I: IntoIterator<Item = Ty<'tcx>>,
     {
-        self.block(vec![], TerminatorKind::Goto { target: self.block_index_offset(3) }, false);
+        self.block(vec![], TerminatorKind::goto(self.block_index_offset(3)), false);
         let unwind = self.block(vec![], TerminatorKind::UnwindResume, true);
         let target = self.block(vec![], TerminatorKind::Return, false);
 
@@ -726,7 +717,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
         coroutine_def_id: DefId,
         args: CoroutineArgs<TyCtxt<'tcx>>,
     ) {
-        self.block(vec![], TerminatorKind::Goto { target: self.block_index_offset(3) }, false);
+        self.block(vec![], TerminatorKind::goto(self.block_index_offset(3)), false);
         let unwind = self.block(vec![], TerminatorKind::UnwindResume, true);
         // This will get overwritten with a switch once we know the target blocks
         let switch = self.block(vec![], TerminatorKind::Unreachable, false);
@@ -744,7 +735,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
                     place: Box::new(Place::return_place()),
                     variant_index,
                 })],
-                TerminatorKind::Goto { target: clone_block },
+                TerminatorKind::goto(clone_block),
                 false,
             );
             cases.push((index as u128, start_block));
@@ -927,7 +918,7 @@ fn build_call_shim<'tcx>(
     let block = |blocks: &mut IndexVec<_, _>, statements, kind, is_cleanup| {
         blocks.push(BasicBlockData::new_stmts(
             statements,
-            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
+            Some(Terminator { source_info, kind }),
             is_cleanup,
         ))
     };
@@ -1054,11 +1045,7 @@ pub(super) fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
 
     let start_block = BasicBlockData::new_stmts(
         vec![statement],
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     );
 
@@ -1141,11 +1128,7 @@ fn build_fn_ptr_as_ptr_shim<'tcx>(
 
     let start_block = BasicBlockData::new_stmts(
         statements,
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     );
     let source = MirSource::from_shim(ty::ShimKind::FnPtrAsPtr(def_id, self_ty));
@@ -1180,11 +1163,7 @@ fn build_fn_ptr_from_ptr_shim<'tcx>(
 
     let start_block = BasicBlockData::new_stmts(
         statements,
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     );
     let source = MirSource::from_shim(ty::ShimKind::FnPtrFromPtr(def_id, self_ty));
@@ -1282,11 +1261,7 @@ fn build_construct_coroutine_by_move_shim<'tcx>(
     let statements = vec![stmt];
     let start_block = BasicBlockData::new_stmts(
         statements,
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     );
 
diff --git a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
index fcc28b20d25a0..7530716e8cf39 100644
--- a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
+++ b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
@@ -85,10 +85,7 @@ pub(super) fn build_async_drop_shim<'tcx>(
     let return_block = BasicBlock::new(1);
     let mut blocks = IndexVec::with_capacity(2);
     let block = |blocks: &mut IndexVec<_, _>, kind| {
-        blocks.push(BasicBlockData::new(
-            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
-            false,
-        ))
+        blocks.push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
     };
     block(
         &mut blocks,
@@ -101,7 +98,7 @@ pub(super) fn build_async_drop_shim<'tcx>(
                 drop: None,
             }
         } else {
-            TerminatorKind::Goto { target: return_block }
+            TerminatorKind::goto(return_block)
         },
     );
     block(&mut blocks, TerminatorKind::Return);
@@ -393,8 +390,6 @@ fn build_adrop_for_adrop_shim<'tcx>(
                 call_source: CallSource::Misc,
                 fn_span: span,
             },
-
-            loop_hint_attrs: ThinVec::new(),
         }),
         false,
     ));
@@ -418,17 +413,11 @@ fn build_adrop_for_adrop_shim<'tcx>(
                 call_source: CallSource::Misc,
                 fn_span: span,
             },
-
-            loop_hint_attrs: ThinVec::new(),
         }),
         false,
     ));
     blocks.push(BasicBlockData::new(
-        Some(Terminator {
-            source_info,
-            kind: TerminatorKind::Return,
-            loop_hint_attrs: ThinVec::new(),
-        }),
+        Some(Terminator { source_info, kind: TerminatorKind::Return }),
         false,
     ));
 
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 32504fc72fecd..c0281871f2a73 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -235,7 +235,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         // We can move all debuginfos to the last basic block.
         let mut trivial_goto_chain = true;
         while let Some(terminator) = self.take_terminator_if_simple_goto(current) {
-            let Terminator { kind: TerminatorKind::Goto { target }, .. } = terminator else {
+            let Terminator { kind: TerminatorKind::Goto { target, .. }, .. } = terminator else {
                 unreachable!();
             };
             trivial_goto_chain &= self.pred_count[target] == 1;
@@ -246,7 +246,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         *changed |= *start != last;
         *start = last;
         while let Some((current, mut terminator)) = terminators.pop() {
-            let Terminator { kind: TerminatorKind::Goto { ref mut target }, .. } = terminator
+            let Terminator { kind: TerminatorKind::Goto { ref mut target, .. }, .. } = terminator
             else {
                 unreachable!();
             };
@@ -284,7 +284,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         terminator: &mut Terminator<'tcx>,
     ) -> bool {
         let target = match terminator.kind {
-            TerminatorKind::Goto { target } if self.pred_count[target] == 1 => target,
+            TerminatorKind::Goto { target, .. } if self.pred_count[target] == 1 => target,
             _ => return false,
         };
 
@@ -325,7 +325,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         self.pred_count[first_succ] -= (count - 1) as u32;
 
         debug!("simplifying branch {:?}", terminator);
-        terminator.kind = TerminatorKind::Goto { target: first_succ };
+        terminator.kind = TerminatorKind::goto(first_succ);
         true
     }
 
diff --git a/compiler/rustc_mir_transform/src/simplify_branches.rs b/compiler/rustc_mir_transform/src/simplify_branches.rs
index 58a3f1b571e59..b25728e15eef3 100644
--- a/compiler/rustc_mir_transform/src/simplify_branches.rs
+++ b/compiler/rustc_mir_transform/src/simplify_branches.rs
@@ -81,14 +81,14 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyConstCondition {
                         && let Some(constant) = c.const_.try_eval_bits(tcx, typing_env) =>
                 {
                     let target = targets.target_for_value(constant);
-                    TerminatorKind::Goto { target }
+                    TerminatorKind::goto(target)
                 }
                 TerminatorKind::Assert { target, ref cond, expected, .. }
                     if let Some(c) = try_get_const(&cond, pre_place_const.take())
                         && let Some(constant) = c.const_.try_eval_bool(tcx, typing_env)
                         && constant == expected =>
                 {
-                    TerminatorKind::Goto { target }
+                    TerminatorKind::goto(target)
                 }
                 _ => continue,
             };
diff --git a/compiler/rustc_mir_transform/src/tail_copy_to_move.rs b/compiler/rustc_mir_transform/src/tail_copy_to_move.rs
index e97844748cefb..c6a55b90d5c6e 100644
--- a/compiler/rustc_mir_transform/src/tail_copy_to_move.rs
+++ b/compiler/rustc_mir_transform/src/tail_copy_to_move.rs
@@ -86,7 +86,7 @@ impl<'tcx> crate::MirPass<'tcx> for TailCopyToMove {
             let mut first = None;
             for pred in predecessors[state.block].iter().copied() {
                 let terminator = body.basic_blocks[pred].terminator();
-                if let TerminatorKind::Goto { target } = terminator.kind {
+                if let TerminatorKind::Goto { target, .. } = terminator.kind {
                     debug_assert_eq!(target, state.block);
                     if first.is_none() {
                         first = Some(pred);
diff --git a/compiler/rustc_mir_transform/src/unreachable_prop.rs b/compiler/rustc_mir_transform/src/unreachable_prop.rs
index 3e03cfe37b75e..eacc263675e15 100644
--- a/compiler/rustc_mir_transform/src/unreachable_prop.rs
+++ b/compiler/rustc_mir_transform/src/unreachable_prop.rs
@@ -30,7 +30,7 @@ impl crate::MirPass<'_> for UnreachablePropagation {
                 TerminatorKind::Unreachable => true,
                 // This will unconditionally run into an unreachable and is therefore unreachable
                 // as well.
-                TerminatorKind::Goto { target } if unreachable_blocks.contains(target) => {
+                TerminatorKind::Goto { target, .. } if unreachable_blocks.contains(target) => {
                     patch.patch_terminator(bb, TerminatorKind::Unreachable);
                     true
                 }
@@ -132,12 +132,12 @@ pub(crate) fn remove_successors_from_switch<'tcx>(
     let terminator = match (num_targets, otherwise_unreachable) {
         // If all targets are unreachable, we can be unreachable as well.
         (1, true) => TerminatorKind::Unreachable,
-        (1, false) => TerminatorKind::Goto { target: otherwise },
+        (1, false) => TerminatorKind::goto(otherwise),
         (2, true) => {
             // All targets are unreachable except one. Record the equality, and make it a goto.
             let (value, target) = new_targets.iter().next().unwrap();
             add_assumption(BinOp::Eq, value);
-            TerminatorKind::Goto { target }
+            TerminatorKind::goto(target)
         }
         _ if num_targets == targets.all_targets().len() => {
             // Nothing has changed.
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 28a508bde9eca..f8afc895bb712 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -339,7 +339,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
 
     fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
         match &terminator.kind {
-            TerminatorKind::Goto { target } => {
+            TerminatorKind::Goto { target, .. } => {
                 self.check_edge(location, *target, EdgeKind::Normal);
             }
             TerminatorKind::SwitchInt { targets, discr: _ } => {
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index c464c310cddf4..9bf83f90e5574 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -733,7 +733,7 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
     ) -> Self::T {
         use crate::mir::TerminatorKind;
         match self {
-            mir::TerminatorKind::Goto { target } => {
+            mir::TerminatorKind::Goto { target, .. } => {
                 TerminatorKind::Goto { target: target.as_usize() }
             }
             mir::TerminatorKind::SwitchInt { discr, targets } => TerminatorKind::SwitchInt {