working autocoercion

Author: xacrimon

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

@@ -160,24 +160,24 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let tcx = self.tcx;
         tracing::warn!("valtree_to_match_pair: {:?} {:?}", subslice_len, src_pat_ty);
 
-        let (const_ty, pat_ty) = match src_pat_ty.kind() { 
-            ty::Slice(_) => {
-                (Ty::new_imm_ref(
+        let (const_ty, pat_ty) = match src_pat_ty.kind() {
+            ty::Slice(_) => (
+                Ty::new_imm_ref(
                     tcx,
                     tcx.lifetimes.re_erased,
                     Ty::new_array(tcx, elem_ty, subslice_len),
                 ),
-                Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_slice(tcx, elem_ty)),)
-            }
-            ty::Array(_, _) => {
-                (Ty::new_imm_ref(
+                Ty::new_slice(tcx, elem_ty),
+            ),
+            ty::Array(_, _) => (
+                Ty::new_imm_ref(
                     tcx,
                     tcx.lifetimes.re_erased,
                     Ty::new_array(tcx, elem_ty, subslice_len),
                 ),
-                Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_array(tcx, elem_ty, subslice_len)),)
-            }
-            _ => todo!()
+                Ty::new_array(tcx, elem_ty, subslice_len),
+            ),
+            _ => todo!(),
         };
 
         let r#const = ty::Const::new(tcx, ty::ConstKind::Value(const_ty, valtree));

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

@@ -10,6 +10,7 @@ use std::cmp::Ordering;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::{LangItem, RangeEnd};
 use rustc_middle::mir::*;
+use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -374,53 +375,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         mut val: Place<'tcx>,
         mut ty: Ty<'tcx>,
     ) {
-        let expect_ty = value.ty();
+        let mut expect_ty = value.ty();
         let expect_op = self.literal_operand(source_info.span, value);
         let mut expect = self.temp(value.ty(), source_info.span);
-        self.cfg.push_assign(
-            block,
-            source_info,
-            expect,
-            Rvalue::Use(expect_op),
-        );
+        self.cfg.push_assign(block, source_info, expect, Rvalue::Use(expect_op));
 
-        match ty.kind() {
-            ty::Ref(_, inner_ty, _) if inner_ty.is_slice() => {
-                let ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
+        let mut normalize_depth = |mut ty: Ty<'tcx>, mut val: Place<'tcx>| {
+            if !ty.is_ref() {
+                ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
                 let temp = self.temp(ty, source_info.span);
                 self.cfg.push_assign(
                     block,
                     source_info,
                     temp,
                     Rvalue::Ref(self.tcx.lifetimes.re_erased, BorrowKind::Shared, val),
                 );
-                ty = ref_ty;
                 val = temp;
-                tracing::warn!("slice ty sig: {:?}", ty);
-            }
-            ty::Ref(_, inner_ty, _) if inner_ty.is_array() => {
-                let ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
-                let temp = self.temp(ref_ty, source_info.span);
-                self.cfg.push_assign(
-                    block,
-                    source_info,
-                    temp,
-                    Rvalue::Ref(self.tcx.lifetimes.re_erased, BorrowKind::Shared, val),
-                );
-
-                ty = ref_ty;
-                val = temp;
-                tracing::warn!("arr ty sig: {:?}", ty);
-            }
-            ty::Ref(_, inner_ty, _) if inner_ty.is_str() => {
-                // nothing yet
-            }
-            _ => todo!("not yet, ty: {:?}", ty),
-        }        
-
-        let mut normalize_depth = |mut ty: Ty<'tcx>, mut val: Place<'tcx>| {
-            if !ty.is_ref() {
-                panic!("not a reference?");
+                return (ty, val);
             }
 
             loop {
@@ -438,15 +409,50 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         tracing::warn!("from {:?} to {:?}", val, temp);
                         val = temp;
                     }
-                    _=> break,
+                    _ => break,
                 }
             }
 
             (ty, val)
         };
 
         (ty, val) = normalize_depth(ty, val);
-        (_, expect) = normalize_depth(expect_ty, expect);
+        (expect_ty, expect) = normalize_depth(expect_ty, expect);
+
+        let mut coerce = |mut ty: Ty<'tcx>, mut place: Place<'tcx>, elem_ty: Ty<'tcx>| {
+            assert!(ty.is_ref() && ty.peel_refs().is_array());
+            let ref_ty = Ty::new_imm_ref(
+                self.tcx,
+                self.tcx.lifetimes.re_erased,
+                Ty::new_slice(self.tcx, elem_ty),
+            );
+
+            let ref_val = self.temp(ref_ty, source_info.span);
+            self.cfg.push_assign(
+                block,
+                source_info,
+                ref_val,
+                Rvalue::Cast(
+                    CastKind::PointerCoercion(PointerCoercion::Unsize, CoercionSource::Implicit),
+                    Operand::Copy(place),
+                    ref_ty,
+                ),
+            );
+
+            ty = ref_ty;
+            place = ref_val;
+            (ty, place)
+        };
+
+        match (ty.peel_refs().kind(), expect_ty.peel_refs().kind()) {
+            (ty::Slice(_), ty::Array(elem_ty, _)) => {
+                (_, expect) = coerce(expect_ty, expect, *elem_ty);
+            }
+            (ty::Array(elem_ty, _), ty::Slice(_)) => {
+                (ty, val) = coerce(ty, val, *elem_ty);
+            }
+            _ => (),
+        }
 
         // Figure out the type on which we are calling `PartialEq`. This involves an extra wrapping
         // reference: we can only compare two `&T`, and then compare_ty will be `T`.