dont store arbitrary parsed attributes in thir

compiler/rustc_codegen_llvm/src/builder.rs

@@ -340,14 +340,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn br_with_attrs(&mut self, dest: &'ll BasicBlock, attributes: &[AttributeKind]) {
+    fn br_with_attrs(&mut self, dest: &'ll BasicBlock, loop_hint_attrs: &[AttributeKind]) {
         unsafe {
             let val = llvm::LLVMBuildBr(self.llbuilder, dest);
 
             let mut nodes = Vec::new();
 
-            for attribute in attributes {
-                let AttributeKind::Unroll(unroll) = attribute else {
+            for loop_hint_attr in loop_hint_attrs {
+                let AttributeKind::Unroll(unroll) = loop_hint_attr else {
                     continue;
                 };
                 // UnrollAttr::Count needs a second operand, the provided count, but the other

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -140,7 +140,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
         bx: &mut Bx,
         target: mir::BasicBlock,
         mergeable_succ: bool,
-        attributes: &[AttributeKind],
+        loop_hint_attrs: &[AttributeKind],
     ) -> MergingSucc {
         let (needs_landing_pad, is_cleanupret) = self.llbb_characteristics(fx, target);
         if mergeable_succ && !needs_landing_pad && !is_cleanupret {
@@ -156,7 +156,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
                 // to a trampoline.
                 bx.cleanup_ret(self.funclet(fx).unwrap(), Some(lltarget));
             } else {
-                bx.br_with_attrs(lltarget, attributes);
+                bx.br_with_attrs(lltarget, loop_hint_attrs);
             }
             MergingSucc::False
         }
@@ -1677,7 +1677,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
 
             mir::TerminatorKind::Goto { target } => {
-                helper.funclet_br(self, bx, target, mergeable_succ(), &terminator.attributes)
+                helper.funclet_br(self, bx, target, mergeable_succ(), &terminator.loop_hint_attrs)
             }
 
             mir::TerminatorKind::SwitchInt { ref discr, ref targets } => {

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -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, _attributes: &[AttributeKind]) {
+    fn br_with_attrs(&mut self, dest: Self::BasicBlock, _loop_hint_attrs: &[AttributeKind]) {
         self.br(dest)
     }
     fn cond_br(

compiler/rustc_middle/src/mir/terminator.rs

@@ -419,7 +419,7 @@ impl<O: fmt::Debug> fmt::Display for AssertKind<O> {
 pub struct Terminator<'tcx> {
     pub source_info: SourceInfo,
     pub kind: TerminatorKind<'tcx>,
-    pub attributes: ThinVec<AttributeKind>,
+    pub loop_hint_attrs: ThinVec<AttributeKind>,
 }
 
 impl<'tcx> Terminator<'tcx> {

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, attributes: _ } = terminator;
+                let Terminator { source_info, kind, loop_hint_attrs: _ } = terminator;
 
                 self.visit_source_info(source_info);
                 match kind {

compiler/rustc_middle/src/thir.rs

@@ -62,7 +62,7 @@ macro_rules! thir_with_elements {
         #[derive(Debug, StableHash, Clone)]
         pub struct Thir<'tcx> {
             pub body_type: BodyTy<'tcx>,
-            pub attributes: FxIndexMap<ExprId, ThinVec<AttributeKind>>,
+            pub loop_hint_attrs: FxIndexMap<ExprId, ThinVec<AttributeKind>>,
             $(
                 pub $name: IndexVec<$id, $value>,
             )*
@@ -72,7 +72,7 @@ macro_rules! thir_with_elements {
             pub fn new(body_type: BodyTy<'tcx>) -> Thir<'tcx> {
                 Thir {
                     body_type,
-                    attributes: FxIndexMap::default(),
+                    loop_hint_attrs: FxIndexMap::default(),
                     $(
                         $name: IndexVec::new(),
                     )*

compiler/rustc_mir_build/src/builder/cfg.rs

@@ -121,7 +121,7 @@ impl<'tcx> CFG<'tcx> {
             self.block_data(block)
         );
         self.block_data_mut(block).terminator =
-            Some(Terminator { source_info, kind, attributes: ThinVec::new() });
+            Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() });
         self.block_data_mut(block).terminator.as_mut().unwrap()
     }
 

compiler/rustc_mir_build/src/builder/custom/parse.rs

@@ -319,7 +319,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
         data.terminator = Some(Terminator {
             source_info: SourceInfo { span, scope: self.source_scope },
             kind: terminator,
-            attributes: ThinVec::new(),
+            loop_hint_attrs: ThinVec::new(),
         });
 
         Ok(data)

compiler/rustc_mir_build/src/builder/expr/into.rs

@@ -238,8 +238,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     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.attributes.get(&expr_id) {
-                        goto.attributes = attrs.clone();
+                    if let Some(attrs) = this.thir.loop_hint_attrs.get(&expr_id) {
+                        goto.loop_hint_attrs = attrs.clone();
                     }
 
                     // Loops are only exited by `break` expressions.

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -57,12 +57,14 @@ impl<'tcx> SplattedFunc<'tcx> {
     }
 }
 
-fn parsed_attrs(id: HirId, tcx: TyCtxt<'_>) -> ThinVec<AttributeKind> {
+fn filter_loop_hint_attrs(id: HirId, tcx: TyCtxt<'_>) -> ThinVec<AttributeKind> {
     HasAttrs::get_attrs(id, &tcx)
         .into_iter()
         .filter_map(|attr| match attr {
-            rustc_attr_ir::Attribute::Parsed(attrkind) => Some(attrkind.clone()),
-            rustc_attr_ir::Attribute::Unparsed(_) => None,
+            rustc_attr_ir::Attribute::Parsed(attrkind @ AttributeKind::Unroll(_)) => {
+                Some(attrkind.clone())
+            }
+            _ => None,
         })
         .collect()
 }
@@ -91,7 +93,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
 
         trace!(?expr.ty);
 
-        let mut attrs = ThinVec::new();
+        let mut loop_hint_attrs = ThinVec::new();
 
         if let hir::ExprKind::Loop(_, _, _, span) = hir_expr.kind {
             match span.desugaring_kind() {
@@ -103,12 +105,12 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     // ignore async for loops
                     if let hir::Node::Expr(expr) = self.tcx.parent_hir_node(expr.hir_id) {
                         std::assert_matches!(expr.kind, hir::ExprKind::DropTemps(..));
-                        attrs = parsed_attrs(expr.hir_id, self.tcx)
+                        loop_hint_attrs = filter_loop_hint_attrs(expr.hir_id, self.tcx)
                     }
                 }
                 // For loops defined with `loop` and `while`, the expr already has the attrs
                 Some(DesugaringKind::WhileLoop) | None => {
-                    attrs = parsed_attrs(hir_expr.hir_id, self.tcx);
+                    loop_hint_attrs = filter_loop_hint_attrs(hir_expr.hir_id, self.tcx);
                 }
                 _ => (),
             }
@@ -128,8 +130,8 @@ impl<'tcx> ThirBuildCx<'tcx> {
         let ty = expr.ty;
         let value = self.thir.exprs.push(expr);
 
-        if !attrs.is_empty() {
-            self.thir.attributes.insert(value, attrs);
+        if !loop_hint_attrs.is_empty() {
+            self.thir.loop_hint_attrs.insert(value, loop_hint_attrs);
         }
 
         // Finally, wrap this up in the expr's scope.

compiler/rustc_mir_dataflow/src/framework/tests.rs

@@ -22,7 +22,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, attributes: ThinVec::new() }),
+            Some(mir::Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
             false,
         ))
     };

compiler/rustc_mir_transform/src/add_call_guards.rs

@@ -92,7 +92,7 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
                 Some(Terminator {
                     source_info,
                     kind: TerminatorKind::Goto { target },
-                    attributes: ThinVec::new(),
+                    loop_hint_attrs: ThinVec::new(),
                 }),
                 is_cleanup,
             );

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -98,7 +98,7 @@ fn add_move_for_packed_drop<'tcx>(
         Some(Terminator {
             source_info,
             kind: TerminatorKind::Goto { target },
-            attributes: ThinVec::new(),
+            loop_hint_attrs: ThinVec::new(),
         }),
         is_cleanup,
     ));

compiler/rustc_mir_transform/src/check_enums.rs

@@ -64,7 +64,7 @@ impl<'tcx> crate::MirPass<'tcx> for CheckEnums {
                             basic_blocks[block].terminator = Some(Terminator {
                                 source_info,
                                 kind: TerminatorKind::Goto { target: new_block },
-                                attributes: ThinVec::new(),
+                                loop_hint_attrs: ThinVec::new(),
                             });
                         }
                         EnumCheckType::Direct { source_op, discr, op_size, valid_discrs } => {
@@ -395,7 +395,7 @@ fn insert_direct_enum_check<'tcx>(
                 invalid_discr_block,
             ),
         },
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 
     // Abort in case of an invalid enum discriminant.
@@ -415,7 +415,7 @@ fn insert_direct_enum_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 }
 
@@ -461,7 +461,7 @@ fn insert_uninhabited_enum_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 }
 
@@ -539,6 +539,6 @@ fn insert_niche_check<'tcx>(
             // make a failing UB check turn into much worse UB when we start unwinding.
             unwind: UnwindAction::Unreachable,
         },
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 }

compiler/rustc_mir_transform/src/check_pointers.rs

@@ -117,7 +117,7 @@ pub(crate) fn check_pointers<'tcx, F>(
                         // worse UB when we start unwinding.
                         unwind: UnwindAction::Unreachable,
                     },
-                    attributes: ThinVec::new(),
+                    loop_hint_attrs: ThinVec::new(),
                 });
             }
         }

compiler/rustc_mir_transform/src/coroutine/drop.rs

@@ -376,7 +376,7 @@ pub(super) fn create_coroutine_drop_shim_proxy_async<'tcx>(
         drop: None,
     };
     body.basic_blocks_mut()[call_bb].terminator =
-        Some(Terminator { source_info, kind, attributes: ThinVec::new() });
+        Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() });
 
     // Run derefer to fix Derefs that are not in the first place
     deref_finder(tcx, &mut body, false);

compiler/rustc_mir_transform/src/coroutine/mod.rs

@@ -256,7 +256,7 @@ impl<'tcx> TransformVisitor<'tcx> {
             Some(Terminator {
                 source_info,
                 kind: TerminatorKind::Return,
-                attributes: ThinVec::new(),
+                loop_hint_attrs: ThinVec::new(),
             }),
             false,
         ));
@@ -744,14 +744,14 @@ fn insert_switch<'tcx>(
     body.basic_blocks_mut()[START_BLOCK].terminator = Some(Terminator {
         source_info: SourceInfo::outermost(body.span),
         kind: switch,
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 }
 
 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, attributes: ThinVec::new() }),
+        Some(Terminator { source_info, kind, loop_hint_attrs: ThinVec::new() }),
         false,
     ))
 }
@@ -776,7 +776,11 @@ 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, attributes: ThinVec::new() }),
+        Some(Terminator {
+            source_info,
+            kind: TerminatorKind::Return,
+            loop_hint_attrs: ThinVec::new(),
+        }),
         false,
     ))
 }
@@ -835,7 +839,7 @@ fn generate_poison_block_and_redirect_unwinds_there<'tcx>(
             source_info,
             kind: TerminatorKind::UnwindResume,
 
-            attributes: ThinVec::new(),
+            loop_hint_attrs: ThinVec::new(),
         }),
         true,
     ));
@@ -851,7 +855,7 @@ fn generate_poison_block_and_redirect_unwinds_there<'tcx>(
                     source_info,
                     kind: TerminatorKind::Goto { target: poison_block },
 
-                    attributes: ThinVec::new(),
+                    loop_hint_attrs: ThinVec::new(),
                 };
             }
         } else if !block.is_cleanup
@@ -1019,7 +1023,7 @@ fn create_cases<'tcx>(
                         source_info,
                         kind: TerminatorKind::Goto { target },
 
-                        attributes: ThinVec::new(),
+                        loop_hint_attrs: ThinVec::new(),
                     }),
                     false,
                 ));

compiler/rustc_mir_transform/src/coverage/tests.rs

@@ -73,7 +73,7 @@ impl<'tcx> MockBlocks<'tcx> {
             Some(Terminator {
                 source_info: SourceInfo::outermost(Span::with_root_ctxt(next_lo, next_hi)),
                 kind,
-                attributes: ThinVec::new(),
+                loop_hint_attrs: ThinVec::new(),
             }),
             false,
         ))

compiler/rustc_mir_transform/src/early_otherwise_branch.rs

@@ -175,7 +175,7 @@ impl<'tcx> crate::MirPass<'tcx> for EarlyOtherwiseBranch {
                         discr: parent_op,
                         targets: eq_targets,
                     },
-                    attributes: ThinVec::new(),
+                    loop_hint_attrs: ThinVec::new(),
                 }),
                 bbs[parent].is_cleanup,
             );
@@ -230,7 +230,7 @@ fn evaluate_candidate<'tcx>(
     let Terminator {
         kind: TerminatorKind::SwitchInt { targets: child_targets, discr: child_discr },
         source_info,
-        attributes: _,
+        loop_hint_attrs: _,
     } = bbs[child].terminator()
     else {
         return None;

compiler/rustc_mir_transform/src/elaborate_drop.rs

@@ -1641,7 +1641,11 @@ 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, attributes: ThinVec::new() }),
+            Some(Terminator {
+                source_info: self.source_info,
+                kind: k,
+                loop_hint_attrs: ThinVec::new(),
+            }),
             unwind.is_cleanup(),
         ))
     }
@@ -1655,7 +1659,11 @@ where
     ) -> BasicBlock {
         self.elaborator.patch().new_block(BasicBlockData::new_stmts(
             statements,
-            Some(Terminator { source_info: self.source_info, kind: k, attributes: ThinVec::new() }),
+            Some(Terminator {
+                source_info: self.source_info,
+                kind: k,
+                loop_hint_attrs: ThinVec::new(),
+            }),
             unwind.is_cleanup(),
         ))
     }

compiler/rustc_mir_transform/src/inline.rs

@@ -872,7 +872,7 @@ fn inline_call<'tcx, I: Inliner<'tcx>>(
             Some(Terminator {
                 source_info: terminator.source_info,
                 kind: TerminatorKind::Goto { target: block },
-                attributes: ThinVec::new(),
+                loop_hint_attrs: ThinVec::new(),
             }),
             caller_body[block].is_cleanup,
         );
@@ -1000,7 +1000,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) },
-        attributes: ThinVec::new(),
+        loop_hint_attrs: ThinVec::new(),
     });
 
     // Copy required constants from the callee_body into the caller_body. Although we are only