optimized cmp of other scalars

Author: xacrimon

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

@@ -116,9 +116,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn is_constant_pattern(&self, pat: &Pat<'tcx>) -> bool {
         if let PatKind::Constant { value } = pat.kind
             && let Const::Ty(_, const_) = value
-            && let ty::ConstKind::Value(ty, valtree) = const_.kind()
+            && let ty::ConstKind::Value(_, valtree) = const_.kind()
             && let ty::ValTree::Leaf(_) = valtree
-            && self.tcx.types.u8 == ty
         {
             true
         } else {

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

@@ -17,7 +17,6 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::DefId;
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
-use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, instrument};
 
 use crate::builder::Builder;
@@ -363,7 +362,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         );
     }
 
-    /// Compare two values using `<T as std::compare::PartialEq>::eq`.
+    /// Compare two values using `<T as std::compare::pattern::MatchLoweredCmp>::do_match`.
     /// If the values are already references, just call it directly, otherwise
     /// take a reference to the values first and then call it.
     fn non_scalar_compare(
@@ -451,36 +450,25 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             (_, expect) = coerce(expect_ty, expect, *elem_ty);
         }
 
-        // Figure out the type we are searching for traits against. This involves an extra wrapping
+        // Figure out the type we are searching for trait impls against. This involves an extra wrapping
         // reference: we can only compare two `&T`, and then compare_ty will be `T`.
         // Make sure that we do *not* call any user-defined code here.
-        // The only types that can end up here are string and byte literals,
+        // The only types that can end up here are str and ScalarInt slices,
         // which have their comparison defined in `core`.
         // (Interestingly this means that exhaustiveness analysis relies, for soundness,
-        // on the `PartialEq` impls for `str` and `[u8]` to b correct!)
+        // on the `MatchLoweredCmp` impls for `str` and `[T]` to be correct!)
         let compare_ty = match *ty.kind() {
-            ty::Ref(_, deref_ty, _)
-                if deref_ty == self.tcx.types.str_ || deref_ty != self.tcx.types.u8 =>
-            {
+            ty::Ref(_, deref_ty, _) if deref_ty == self.tcx.types.str_ || deref_ty.is_slice() => {
                 deref_ty
             }
             _ => span_bug!(source_info.span, "invalid type for non-scalar compare: {}", ty),
         };
 
-        let mut cmp_trait_def_id =
+        let cmp_trait_def_id =
             self.tcx.require_lang_item(LangItem::MatchLoweredCmp, Some(source_info.span));
-
-        let has_pattern_eq = self
-            .infcx
-            .type_implements_trait(cmp_trait_def_id, [compare_ty], self.param_env)
-            .must_apply_modulo_regions();
-        if !has_pattern_eq {
-            cmp_trait_def_id =
-                self.tcx.require_lang_item(LangItem::PartialEq, Some(source_info.span));
-        }
-
         let method =
             trait_method(self.tcx, cmp_trait_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);
         let eq_block = self.cfg.start_new_block();

library/core/src/cmp/pattern.rs

@@ -8,8 +8,6 @@ where
     fn do_match(&self, other: &Rhs) -> bool;
 }
 
-// TODO: tuples, arrays?
-
 macro_rules ! impl_match_lowered_cmp_for_primitive {
     ($($t:ty),*) => {
         $(
@@ -23,13 +21,12 @@ macro_rules ! impl_match_lowered_cmp_for_primitive {
 }
 
 impl_match_lowered_cmp_for_primitive! {
-    (), bool, char,
+    bool, char,
     u8, u16, u32, u64, u128, usize,
     i8, i16, i32, i64, i128, isize,
     f32, f64
 }
 
-// note: this wasn't possible before
 impl const MatchLoweredCmp for str {
     #[rustc_allow_const_fn_unstable(const_trait_impl)]
     fn do_match(&self, other: &Self) -> bool {