deeply_normalize tys in check_tys_might_be_eq

Co-authored-by: Boxy <[email protected]>

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -215,8 +215,12 @@ pub fn check_tys_might_be_eq<'tcx>(
     let (infcx, key, _) = tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &canonical);
     let (param_env, (ty_a, ty_b)) = key.into_parts();
     let ocx = ObligationCtxt::new(&infcx);
+    let cause = ObligationCause::dummy();
+
+    let ty_a = ocx.deeply_normalize(&cause, param_env, ty_a).unwrap_or(ty_a);
+    let ty_b = ocx.deeply_normalize(&cause, param_env, ty_b).unwrap_or(ty_b);
+    let result = ocx.eq(&cause, param_env, ty_a, ty_b);
 
-    let result = ocx.eq(&ObligationCause::dummy(), param_env, ty_a, ty_b);
     // use `select_where_possible` instead of `select_all_or_error` so that
     // we don't get errors from obligations being ambiguous.
     let errors = ocx.select_where_possible();

tests/ui/type-alias/normalize-const-tys-2.rs

@@ -0,0 +1,20 @@
+//! Issue #114456: `deeply_normalize` tys in `check_tys_might_be_eq`
+//@ check-pass
+#![feature(adt_const_params)]
+#![allow(incomplete_features)]
+
+enum Type {}
+trait Trait { type Matrix; }
+impl Trait for Type { type Matrix = [usize; 1]; }
+
+struct Walk<const REMAINING: <Type as Trait>::Matrix> {}
+
+impl Walk<{ [0; 1] }> {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+fn main() {
+    let _ = Walk::new();
+}

tests/ui/type-alias/normalize-const-tys.rs

@@ -0,0 +1,17 @@
+//! Issue #114456: `deeply_normalize` tys in `check_tys_might_be_eq`
+//@ check-pass
+#![feature(adt_const_params, lazy_type_alias)]
+#![allow(incomplete_features)]
+
+type Matrix = [usize; 1];
+struct Walk<const REMAINING: Matrix> {}
+
+impl Walk<{ [0; 1] }> {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+fn main() {
+    let _ = Walk::new();
+}