woes with const stability

Author: xacrimon

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -280,6 +280,7 @@ fn build_error_for_const_call<'tcx>(
             } else {
                 let mut sugg = None;
 
+                // TODO: update this
                 if ccx.tcx.is_lang_item(trait_id, LangItem::PartialEq) {
                     match (args[0].unpack(), args[1].unpack()) {
                         (GenericArgKind::Type(self_ty), GenericArgKind::Type(rhs_ty))

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

@@ -152,6 +152,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> MatchPairTree<'pat, 'tcx> {
         let tcx = self.tcx;
 
+        // TODO: should these be arrays?
         let (const_ty, pat_ty) = match src_pat_ty.kind() {
             ty::Slice(_) => (
                 Ty::new_imm_ref(

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

@@ -442,14 +442,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             (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);
-            }
-            _ => (),
+        //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);
+        //    }
+        //    _ => (),
+        //}
+
+        if let ty::Array(elem_ty, _) = ty.peel_refs().kind() {
+            (ty, val) = coerce(ty, val, *elem_ty);
+        }
+
+        if let ty::Array(elem_ty, _) = expect_ty.peel_refs().kind() {
+            (_, expect) = coerce(expect_ty, expect, *elem_ty);
         }
 
         // Figure out the type on which we are calling `PartialEq`. This involves an extra wrapping
@@ -468,8 +476,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             _ => span_bug!(source_info.span, "invalid type for non-scalar compare: {}", ty),
         };
 
-        let eq_def_id = self.tcx.require_lang_item(LangItem::PartialEq, Some(source_info.span));
-        let method = trait_method(self.tcx, eq_def_id, sym::eq, [compare_ty, compare_ty]);
+        let eq_def_id = self.tcx.require_lang_item(LangItem::MatchLoweredCmp, Some(source_info.span));
+        let method = trait_method(self.tcx, eq_def_id, sym::do_match, [compare_ty, compare_ty]);
 
         let bool_ty = self.tcx.types.bool;
         let eq_result = self.temp(bool_ty, source_info.span);

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

@@ -229,8 +229,3 @@ pub(crate) fn ref_pat_borrow_kind(ref_mutability: Mutability) -> BorrowKind {
         Mutability::Not => BorrowKind::Shared,
     }
 }
-
-#[lang = "MatchLoweredCmp"]
-pub trait MatchLoweredCmp {
-    fn same_as(&self, other: &Self) -> bool;
-}

compiler/rustc_span/src/symbol.rs

@@ -783,6 +783,7 @@ symbols! {
         div,
         div_assign,
         diverging_block_default,
+        do_match,
         do_not_recommend,
         doc,
         doc_alias,

library/core/src/cmp.rs

@@ -25,6 +25,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+mod pattern;
 mod bytewise;
 pub(crate) use bytewise::BytewiseEq;
 

library/core/src/cmp/pattern.rs

@@ -0,0 +1,65 @@
+#[lang = "MatchLoweredCmp"]
+#[const_trait]
+trait MatchLoweredCmp<Rhs: ?Sized = Self> {
+    #[allow(dead_code)]
+    fn do_match(&self, other: &Rhs) -> bool;
+}
+
+impl const MatchLoweredCmp for u8 {
+    fn do_match(&self, other: &Self) -> bool {
+        *self == *other
+    }
+}
+
+// TODO: should this be here considering the possible optimized eq target outputs?
+impl const MatchLoweredCmp for [u8] {
+    fn do_match(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+
+        let mut i = 0;
+
+        while i < self.len() {
+            if self[i] != other[i] {
+                return false;
+            }
+
+            i += 1;
+        }
+
+        true
+    }
+}
+
+//impl<const N:usize> const MatchLoweredCmp for [u8; N] {
+//    fn do_match(&self, other: &Self) -> bool {
+//        let mut i = 0;
+//
+//        while i < N {
+//            if self[i] != other[i] {
+//                return false;
+//            }
+//            i += 1;
+//        }
+//
+//        true
+//    }
+//}
+
+impl<T, Rhs> MatchLoweredCmp<Rhs> for T where T: PartialEq<Rhs>,
+{
+    default fn do_match(&self, other: &Rhs) -> bool {
+        <Self as PartialEq<Rhs>>::eq(self, other)
+    }
+}
+
+// #[rustc_const_stable_indirect]
+// #[rustc_allow_const_fn_unstable]
+// #[allow_internal_unstable]
+
+//#[rustc_const_stable_indirect]
+
+// wrap with fn?
+// macro
+// scary attrib

tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr

@@ -22,7 +22,7 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL | const fn bar2() -> u32 { foo2() }
    |                          ^^^^^^
    |
-   = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
+   = help: mark the callee as `#` if it does not itself require any unstable features
 help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]