lang item escape hatch

Author: xacrimon

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -702,6 +702,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     // We can't determine the actual callee here, so we have to do different checks
                     // than usual.
 
+                    if tcx.is_lang_item(trait_did, LangItem::MatchLoweredCmp) {
+                        return;
+                    }
+
                     trace!("attempting to call a trait method");
                     let trait_is_const = tcx.is_const_trait(trait_did);
 

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

@@ -442,22 +442,14 @@ 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);
-        //    }
-        //    _ => (),
-        //}
-
-        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);
+        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
@@ -476,7 +468,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::MatchLoweredCmp, Some(source_info.span));
+        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;

library/core/src/cmp.rs

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

library/core/src/cmp/pattern.rs

@@ -1,6 +1,9 @@
 #[lang = "MatchLoweredCmp"]
 #[const_trait]
-trait MatchLoweredCmp<Rhs: ?Sized = Self> {
+trait MatchLoweredCmp<Rhs = Self>
+where
+    Rhs: ?Sized,
+{
     #[allow(dead_code)]
     fn do_match(&self, other: &Rhs) -> bool;
 }
@@ -11,8 +14,18 @@ impl const MatchLoweredCmp for u8 {
     }
 }
 
-// TODO: should this be here considering the possible optimized eq target outputs?
-impl const MatchLoweredCmp for [u8] {
+impl const MatchLoweredCmp for str {
+    #[rustc_allow_const_fn_unstable(const_trait_impl)]
+    fn do_match(&self, other: &Self) -> bool {
+        <[u8] as MatchLoweredCmp>::do_match((*self).as_bytes(), (*other).as_bytes())
+    }
+}
+
+impl<T> const MatchLoweredCmp for [T]
+where
+    T: ~const MatchLoweredCmp,
+{
+    #[rustc_allow_const_fn_unstable(const_trait_impl)]
     fn do_match(&self, other: &Self) -> bool {
         if self.len() != other.len() {
             return false;
@@ -21,7 +34,7 @@ impl const MatchLoweredCmp for [u8] {
         let mut i = 0;
 
         while i < self.len() {
-            if self[i] != other[i] {
+            if <T as MatchLoweredCmp>::do_match(&self[i], &other[i]) == false {
                 return false;
             }
 
@@ -32,34 +45,19 @@ impl const MatchLoweredCmp for [u8] {
     }
 }
 
-//impl<const N:usize> const MatchLoweredCmp for [u8; N] {
+//impl<const N:usize, T> const MatchLoweredCmp for [T; N] where T: ~const MatchLoweredCmp {
+//    #[rustc_allow_const_fn_unstable(const_trait_impl)]
 //    fn do_match(&self, other: &Self) -> bool {
 //        let mut i = 0;
 //
 //        while i < N {
-//            if self[i] != other[i] {
+//            if <T as MatchLoweredCmp>::do_match(&self[i], &other[i]) == false {
 //                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