Merge the AggregateEq and StringEq test arms into a single case

Author: jakubadamw

compiler/rustc_mir_build/src/builder/matches/test.rs

@@ -140,85 +140,47 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.cfg.terminate(block, self.source_info(match_start_span), terminator);
             }
 
-            TestKind::StringEq { value } => {
+            TestKind::StringEq { value } | TestKind::AggregateEq { value } => {
                 let tcx = self.tcx;
                 let success_block = target_block(TestBranch::Success);
                 let fail_block = target_block(TestBranch::Failure);
 
-                let ref_str_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, tcx.types.str_);
-                assert!(ref_str_ty.is_imm_ref_str(), "{ref_str_ty:?}");
+                let inner_ty = value.ty;
+                let ref_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, inner_ty);
 
-                // The string constant we're testing against has type `str`, but
-                // calling `<str as PartialEq>::eq` requires `&str` operands.
-                //
-                // Because `str` and `&str` have the same valtree representation,
-                // we can "cast" to the desired type by just replacing the type.
-                assert!(value.ty.is_str(), "unexpected value type for StringEq test: {value:?}");
-                let expected_value = ty::Value { ty: ref_str_ty, valtree: value.valtree };
+                // The constant we're testing against has type `str`, `[T; N]`, or `[T]`,
+                // but calling `<T as PartialEq>::eq` requires a reference operand
+                // (`&str`, `&[T; N]`, or `&[T]`). Valtree representations are the same
+                // with or without the reference wrapper, so we can "cast" to the
+                // desired type by just replacing the type.
+                let expected_value = ty::Value { ty: ref_ty, valtree: value.valtree };
                 let expected_value_operand =
                     self.literal_operand(test.span, Const::from_ty_value(tcx, expected_value));
 
-                // Similarly, the scrutinized place has type `str`, but we need `&str`.
-                // Get a reference by doing `let actual_value_ref_place: &str = &place`.
-                let actual_value_ref_place = self.temp(ref_str_ty, test.span);
+                // Similarly, the scrutinised place has the inner type, but we need a
+                // reference. Get one by doing `let actual_value_ref_place = &place`.
+                let actual_value_ref_place = self.temp(ref_ty, test.span);
                 self.cfg.push_assign(
                     block,
                     self.source_info(test.span),
                     actual_value_ref_place,
                     Rvalue::Ref(tcx.lifetimes.re_erased, BorrowKind::Shared, place),
                 );
 
-                // Compare two strings using `<str as std::cmp::PartialEq>::eq`.
-                // (Interestingly this means that exhaustiveness analysis relies, for soundness,
-                // on the `PartialEq` impl for `str` to be correct!)
+                // Compare the two values using `<T as std::cmp::PartialEq>::eq`.
+                // (Interestingly this means that, for `str`, exhaustiveness analysis
+                // relies for soundness on the `PartialEq` impl for `str` to be correct!)
                 self.non_scalar_compare(
                     block,
                     success_block,
                     fail_block,
                     source_info,
-                    tcx.types.str_,
+                    inner_ty,
                     expected_value_operand,
                     Operand::Copy(actual_value_ref_place),
                 );
             }
 
-            TestKind::AggregateEq { value } => {
-                let tcx = self.tcx;
-                let success_block = target_block(TestBranch::Success);
-                let fail_block = target_block(TestBranch::Failure);
-
-                let aggregate_ty = value.ty;
-                let ref_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, aggregate_ty);
-
-                // The constant has type `[T; N]` (or `[T]`), but calling
-                // `PartialEq::eq` requires `&[T; N]` (or `&[T]`) operands.
-                // Valtree representations are the same with or without the
-                // reference wrapper, so we can reinterpret by replacing the type.
-                let expected_value = ty::Value { ty: ref_ty, valtree: value.valtree };
-                let expected_operand =
-                    self.literal_operand(test.span, Const::from_ty_value(tcx, expected_value));
-
-                // Create a reference to the scrutinee place.
-                let actual_ref_place = self.temp(ref_ty, test.span);
-                self.cfg.push_assign(
-                    block,
-                    self.source_info(test.span),
-                    actual_ref_place,
-                    Rvalue::Ref(tcx.lifetimes.re_erased, BorrowKind::Shared, place),
-                );
-
-                // Compare using `<T as PartialEq>::eq` where `T` is the array or slice type.
-                self.non_scalar_compare(
-                    block,
-                    success_block,
-                    fail_block,
-                    source_info,
-                    aggregate_ty,
-                    expected_operand,
-                    Operand::Copy(actual_ref_place),
-                );
-            }
-
             TestKind::ScalarEq { value } => {
                 let tcx = self.tcx;
                 let success_block = target_block(TestBranch::Success);