Auto merge of rust-lang#156542 - cyrgani:unbox-3, r=Nadrieril

remove `box_patterns` from remaining compiler crates

Part of rust-lang#156110.

Author: bors

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

@@ -53,7 +53,7 @@ macro_rules! parse_by_kind {
                 } => $call_expr,
             )*
             $(
-                ExprKind::Adt(box AdtExpr { adt_def, variant_index, .. }) if {
+                ExprKind::Adt(AdtExpr { adt_def, variant_index, .. }) if {
                     $self.tcx.is_diagnostic_item(rustc_span::sym::$adt, adt_def.did()) &&
                     adt_def.variants()[*variant_index].name == rustc_span::sym::$variant
                 } => $variant_expr,

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

@@ -275,7 +275,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                     fields.iter().map(|e| self.parse_operand(*e)).collect::<Result<_, _>>()?
                 ))
             },
-            ExprKind::Adt(box AdtExpr { adt_def, variant_index, args, fields, .. }) => {
+            ExprKind::Adt(AdtExpr { adt_def, variant_index, args, fields, .. }) => {
                 let is_union = adt_def.is_union();
                 let active_field_index = is_union.then(|| fields[0].name);
 

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

@@ -242,7 +242,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 block.and(Rvalue::Aggregate(Box::new(AggregateKind::Tuple), fields))
             }
-            ExprKind::Closure(box ClosureExpr {
+            ExprKind::Closure(ClosureExpr {
                 closure_id,
                 args,
                 ref upvars,

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

@@ -247,7 +247,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ExprKind::LoopMatch {
                 state,
                 region_scope,
-                match_data: box LoopMatchMatchData { box ref arms, span: match_span, scrutinee },
+                match_data: LoopMatchMatchData { ref arms, span: match_span, scrutinee },
             } => {
                 // Intuitively, this is a combination of a loop containing a labeled block
                 // containing a match.
@@ -347,7 +347,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             LintLevel::Inherited,
                             move |this| {
                                 this.in_const_continuable_scope(
-                                    Box::from(arms),
+                                    arms.clone(),
                                     built_tree.clone(),
                                     state_place,
                                     expr_span,
@@ -587,7 +587,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.push_assign(block, source_info, destination, address_of);
                 block.unit()
             }
-            ExprKind::Adt(box AdtExpr {
+            ExprKind::Adt(AdtExpr {
                 adt_def,
                 variant_index,
                 args,
@@ -698,7 +698,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 );
                 block.unit()
             }
-            ExprKind::InlineAsm(box InlineAsmExpr {
+            ExprKind::InlineAsm(InlineAsmExpr {
                 asm_macro,
                 template,
                 ref operands,

compiler/rustc_mir_build/src/builder/mod.rs

@@ -885,7 +885,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             for stmt in &bb.statements {
                 match &stmt.kind {
                     // Ignore the implicit `()` return place assignment for unit functions/blocks
-                    StatementKind::Assign(box (_, Rvalue::Use(Operand::Constant(const_), _)))
+                    StatementKind::Assign((_, Rvalue::Use(Operand::Constant(const_), _)))
                         if const_.ty().is_unit() =>
                     {
                         continue;

compiler/rustc_mir_build/src/builder/scope.rs

@@ -892,7 +892,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let expr = &self.thir[value];
         let constant = match &expr.kind {
-            ExprKind::Adt(box AdtExpr { variant_index, fields, base, .. }) => {
+            ExprKind::Adt(AdtExpr { variant_index, fields, base, .. }) => {
                 assert!(matches!(base, AdtExprBase::None));
                 assert!(fields.is_empty());
                 ConstOperand {

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -510,7 +510,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                     self.requires_unsafe(expr.span, DerefOfRawPointer);
                 }
             }
-            ExprKind::InlineAsm(box InlineAsmExpr {
+            ExprKind::InlineAsm(InlineAsmExpr {
                 asm_macro: asm_macro @ (AsmMacro::Asm | AsmMacro::NakedAsm),
                 ref operands,
                 template: _,
@@ -554,7 +554,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 }
                 return;
             }
-            ExprKind::Adt(box AdtExpr {
+            ExprKind::Adt(AdtExpr {
                 adt_def,
                 variant_index,
                 args: _,
@@ -566,7 +566,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                     self.requires_unsafe(expr.span, InitializingTypeWithUnsafeField)
                 }
             }
-            ExprKind::Closure(box ClosureExpr {
+            ExprKind::Closure(ClosureExpr {
                 closure_id,
                 args: _,
                 upvars: _,

compiler/rustc_mir_build/src/lib.rs

@@ -1,7 +1,7 @@
 //! Construction of MIR from HIR.
 
 // tidy-alphabetical-start
-#![feature(box_patterns)]
+#![feature(deref_patterns)]
 #![feature(try_blocks)]
 // tidy-alphabetical-end
 

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -60,7 +60,7 @@ pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), Err
     };
 
     for param in thir.params.iter() {
-        if let Some(box ref pattern) = param.pat {
+        if let Some(ref pattern) = param.pat {
             visitor.check_binding_is_irrefutable(pattern, origin, None, None);
         }
     }
@@ -149,16 +149,16 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
                 }
                 return;
             }
-            ExprKind::Match { scrutinee, box ref arms, match_source } => {
+            ExprKind::Match { scrutinee, ref arms, match_source } => {
                 self.check_match(scrutinee, arms, match_source, ex.span);
             }
             ExprKind::LoopMatch {
-                match_data: box LoopMatchMatchData { scrutinee, box ref arms, span },
+                match_data: LoopMatchMatchData { scrutinee, ref arms, span },
                 ..
             } => {
                 self.check_match(scrutinee, arms, MatchSource::Normal, span);
             }
-            ExprKind::Let { box ref pat, expr } => {
+            ExprKind::Let { ref pat, expr } => {
                 self.check_let(pat, Some(expr), ex.span, None);
             }
             ExprKind::LogicalOp { op: LogicalOp::And, .. }
@@ -179,7 +179,7 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
 
     fn visit_stmt(&mut self, stmt: &'p Stmt<'tcx>) {
         match stmt.kind {
-            StmtKind::Let { box ref pattern, initializer, else_block, hir_id, span, .. } => {
+            StmtKind::Let { ref pattern, initializer, else_block, hir_id, span, .. } => {
                 self.with_hir_source(hir_id, |this| {
                     let let_source =
                         if else_block.is_some() { LetSource::LetElse } else { LetSource::PlainLet };
@@ -251,7 +251,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             ExprKind::Scope { value, hir_id, .. } => {
                 self.with_hir_source(hir_id, |this| this.visit_land_rhs(&this.thir[value]))
             }
-            ExprKind::Let { box ref pat, expr } => {
+            ExprKind::Let { ref pat, expr } => {
                 let expr = &self.thir()[expr];
                 self.with_let_source(LetSource::None, |this| {
                     this.visit_expr(expr);
@@ -466,7 +466,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             && self.tcx.is_diagnostic_item(rustc_span::sym::Option, s_ty.did())
             && let ExprKind::Scope { value, .. } = initializer.kind
             && let initializer_expr = &self.thir[value]
-            && let ExprKind::Adt(box AdtExpr { fields, .. }) = &initializer_expr.kind
+            && let ExprKind::Adt(AdtExpr { fields, .. }) = &initializer_expr.kind
             && let Some(field) = fields.first()
             && let inner = &self.thir[field.expr]
             && let Some(inner_ty) = inner.ty.ty_adt_def()
@@ -754,7 +754,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
 /// This analysis is *not* subsumed by NLL.
 fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat: &Pat<'tcx>) {
     // Extract `sub` in `binding @ sub`.
-    let PatKind::Binding { name, mode, ty, subpattern: Some(box ref sub), .. } = pat.kind else {
+    let PatKind::Binding { name, mode, ty, subpattern: Some(ref sub), .. } = pat.kind else {
         return;
     };
 

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -177,7 +177,7 @@ impl<'tcx, 'ptcx> PatCtxt<'tcx, 'ptcx> {
         // Lower the endpoint into a temporary `thir::Pat` that will then be
         // deconstructed to obtain the constant value and other data.
         let endpoint_pat: Box<Pat<'tcx>> = self.lower_pat_expr(pat, expr);
-        let box Pat { ref kind, extra, .. } = endpoint_pat;
+        let Pat { ref kind, extra, .. } = endpoint_pat;
 
         // Preserve any ascriptions from endpoint constants.
         if let Some(extra) = extra {