rename and disallow matching str in const

Author: xacrimon

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -702,7 +702,7 @@ 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) {
+                    if tcx.is_lang_item(trait_did, LangItem::PatternConstEq) {
                         return;
                     }
 

compiler/rustc_hir/src/lang_items.rs

@@ -419,7 +419,7 @@ language_item_table! {
     CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
 
     // FIXME(xacrimon): Used for lowering of match/if let statements. will made obsolete by const PartialEq.
-    MatchLoweredCmp,         sym::MatchLoweredCmp,     match_lowered_cmp,          Target::Trait,          GenericRequirement::None;
+    PatternConstEq,          sym::PatternConstEq,      pattern_const_eq,          Target::Trait,          GenericRequirement::None;
 }
 
 pub enum GenericRequirement {

compiler/rustc_middle/src/arena.rs

@@ -114,7 +114,7 @@ macro_rules! arena_types {
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
-            [] pats2: rustc_middle::thir::Pat<'tcx>,
+            [] thir_pat: rustc_middle::thir::Pat<'tcx>,
         ]);
     )
 }

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

@@ -17,6 +17,7 @@ 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;
@@ -362,7 +363,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         );
     }
 
-    /// Compare two values using `<T as std::compare::pattern::MatchLoweredCmp>::do_match`.
+    /// Compare two values using `<T as std::compare::pattern::PatternConstEq>::eq`.
     /// 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(
@@ -456,19 +457,30 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // 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 `MatchLoweredCmp` impls for `str` and `[T]` to be correct!)
+        // on the `PatternConstEq` and `PartialEq` 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.is_slice() => {
                 deref_ty
             }
             _ => span_bug!(source_info.span, "invalid type for non-scalar compare: {}", ty),
         };
 
-        let cmp_trait_def_id =
-            self.tcx.require_lang_item(LangItem::MatchLoweredCmp, Some(source_info.span));
-        let method =
-            trait_method(self.tcx, cmp_trait_def_id, sym::do_match, [compare_ty, compare_ty]);
+        let const_cmp_trait_def =
+            self.tcx.require_lang_item(LangItem::PatternConstEq, Some(source_info.span));
+        let fallback_cmp_trait_def =
+            self.tcx.require_lang_item(LangItem::PartialEq, Some(source_info.span));
+
+        let cmp_trait_def = if self
+            .infcx
+            .type_implements_trait(const_cmp_trait_def, [compare_ty, compare_ty], self.param_env)
+            .must_apply_modulo_regions()
+        {
+            const_cmp_trait_def
+        } else {
+            fallback_cmp_trait_def
+        };
 
+        let method = trait_method(self.tcx, cmp_trait_def, sym::eq, [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();

compiler/rustc_span/src/symbol.rs

@@ -267,7 +267,6 @@ symbols! {
         LintDiagnostic,
         LintPass,
         LocalKey,
-        MatchLoweredCmp,
         Mutex,
         MutexGuard,
         N,
@@ -287,6 +286,7 @@ symbols! {
         PartialOrd,
         Path,
         PathBuf,
+        PatternConstEq,
         Pending,
         PinCoerceUnsized,
         Pointer,
@@ -783,7 +783,6 @@ symbols! {
         div,
         div_assign,
         diverging_block_default,
-        do_match,
         do_not_recommend,
         doc,
         doc_alias,

library/core/src/cmp/pattern.rs

@@ -2,21 +2,21 @@ use crate::cmp::BytewiseEq;
 use crate::intrinsics::compare_bytes;
 use crate::mem;
 
-#[lang = "MatchLoweredCmp"]
+#[lang = "PatternConstEq"]
 #[const_trait]
-trait MatchLoweredCmp<Rhs = Self>
+trait PatternConstEq<Rhs = Self>
 where
     Rhs: ?Sized,
 {
     #[allow(dead_code)]
-    fn do_match(&self, other: &Rhs) -> bool;
+    fn eq(&self, other: &Rhs) -> bool;
 }
 
 macro_rules ! impl_for_primitive {
     ($($t:ty),*) => {
         $(
-            impl const MatchLoweredCmp for $t {
-                fn do_match(&self, other: &Self) -> bool {
+            impl const PatternConstEq for $t {
+                fn eq(&self, other: &Self) -> bool {
                     *self == *other
                 }
             }
@@ -31,25 +31,19 @@ impl_for_primitive! {
     f32, f64
 }
 
-impl const MatchLoweredCmp for str {
-    fn do_match(&self, other: &Self) -> bool {
-        <[u8] as MatchLoweredCmp>::do_match((*self).as_bytes(), (*other).as_bytes())
-    }
-}
-
-impl<T> const MatchLoweredCmp for [T]
+impl<T> const PatternConstEq for [T]
 where
-    T: ~const MatchLoweredCmp,
+    T: ~const PatternConstEq,
 {
-    default fn do_match(&self, other: &Self) -> bool {
+    default fn eq(&self, other: &Self) -> bool {
         if self.len() != other.len() {
             return false;
         }
 
         let mut i = 0;
 
         while i < self.len() {
-            if <T as MatchLoweredCmp>::do_match(&self[i], &other[i]) == false {
+            if <T as PatternConstEq>::eq(&self[i], &other[i]) == false {
                 return false;
             }
 
@@ -61,11 +55,11 @@ where
 }
 
 #[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]
-impl<T> const MatchLoweredCmp for [T]
+impl<T> const PatternConstEq for [T]
 where
-    T: ~const MatchLoweredCmp + BytewiseEq<T>,
+    T: ~const PatternConstEq + BytewiseEq<T>,
 {
-    fn do_match(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Self) -> bool {
         if self.len() != other.len() {
             return false;
         }