Allow defining opaque types when checking const equality bounds

Author: oli-obk

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -577,7 +577,9 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                 if let Ok(new_obligations) = infcx
                                     .at(&obligation.cause, obligation.param_env)
                                     .trace(c1, c2)
-                                    .eq(DefineOpaqueTypes::No, a.args, b.args)
+                                    // Can define opaque types as this is only reachable with
+                                    // `generic_const_exprs`
+                                    .eq(DefineOpaqueTypes::Yes, a.args, b.args)
                                 {
                                     return ProcessResult::Changed(mk_pending(
                                         new_obligations.into_obligations(),
@@ -588,7 +590,9 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                             (_, _) => {
                                 if let Ok(new_obligations) = infcx
                                     .at(&obligation.cause, obligation.param_env)
-                                    .eq(DefineOpaqueTypes::No, c1, c2)
+                                    // Can define opaque types as this is only reachable with
+                                    // `generic_const_exprs`
+                                    .eq(DefineOpaqueTypes::Yes, c1, c2)
                                 {
                                     return ProcessResult::Changed(mk_pending(
                                         new_obligations.into_obligations(),
@@ -629,7 +633,9 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                     match (evaluate(c1), evaluate(c2)) {
                         (Ok(c1), Ok(c2)) => {
                             match self.selcx.infcx.at(&obligation.cause, obligation.param_env).eq(
-                                DefineOpaqueTypes::No,
+                                // Can define opaque types as this is only reachable with
+                                // `generic_const_exprs`
+                                DefineOpaqueTypes::Yes,
                                 c1,
                                 c2,
                             ) {

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -922,7 +922,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                     .infcx
                                     .at(&obligation.cause, obligation.param_env)
                                     .trace(c1, c2)
-                                    .eq(DefineOpaqueTypes::No, a.args, b.args)
+                                    // Can define opaque types as this is only reachable with
+                                    // `generic_const_exprs`
+                                    .eq(DefineOpaqueTypes::Yes, a.args, b.args)
                                 {
                                     return self.evaluate_predicates_recursively(
                                         previous_stack,
@@ -935,7 +937,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 if let Ok(InferOk { obligations, value: () }) = self
                                     .infcx
                                     .at(&obligation.cause, obligation.param_env)
-                                    .eq(DefineOpaqueTypes::No, c1, c2)
+                                    // Can define opaque types as this is only reachable with
+                                    // `generic_const_exprs`
+                                    .eq(DefineOpaqueTypes::Yes, c1, c2)
                                 {
                                     return self.evaluate_predicates_recursively(
                                         previous_stack,
@@ -965,7 +969,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     match (evaluate(c1), evaluate(c2)) {
                         (Ok(c1), Ok(c2)) => {
                             match self.infcx.at(&obligation.cause, obligation.param_env).eq(
-                                DefineOpaqueTypes::No,
+                                // Can define opaque types as this is only reachable with
+                                // `generic_const_exprs`
+                                DefineOpaqueTypes::Yes,
                                 c1,
                                 c2,
                             ) {

tests/ui/const-generics/generic_const_exprs/opaque_type.rs

@@ -9,7 +9,6 @@ where
     [u8; (N / 2) as usize]: Sized,
 {
     let _: [u8; (N / 2) as Foo] = [0; (N / 2) as usize];
-    //~^ ERROR: mismatched types
     todo!()
 }
 

tests/ui/const-generics/generic_const_exprs/opaque_type.stderr

@@ -9,11 +9,48 @@ note: ...which requires computing type of opaque `Foo::{opaque#0}`...
    |
 LL | type Foo = impl Sized;
    |            ^^^^^^^^^^
-note: ...which requires type-checking `with_bound`...
-  --> $DIR/opaque_type.rs:11:35
+note: ...which requires borrow-checking `with_bound`...
+  --> $DIR/opaque_type.rs:7:1
    |
-LL |     let _: [u8; (N / 2) as Foo] = [0; (N / 2) as usize];
-   |                                   ^^^^^^^^^^^^^^^^^^^^^
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
+note: ...which requires promoting constants in MIR for `with_bound`...
+  --> $DIR/opaque_type.rs:7:1
+   |
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
+note: ...which requires preparing `with_bound` for borrow checking...
+  --> $DIR/opaque_type.rs:7:1
+   |
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
+note: ...which requires checking if `with_bound` contains FFI-unwind calls...
+  --> $DIR/opaque_type.rs:7:1
+   |
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
+note: ...which requires building MIR for `with_bound`...
+  --> $DIR/opaque_type.rs:7:1
+   |
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
+note: ...which requires match-checking `with_bound`...
+  --> $DIR/opaque_type.rs:7:1
+   |
+LL | / fn with_bound<const N: usize>() -> Foo
+LL | | where
+LL | |     [u8; (N / 2) as usize]: Sized,
+   | |__________________________________^
 note: ...which requires evaluating type-level constant...
   --> $DIR/opaque_type.rs:11:17
    |
@@ -43,16 +80,6 @@ LL | type Foo = impl Sized;
    |            ^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0308]: mismatched types
-  --> $DIR/opaque_type.rs:11:35
-   |
-LL |     let _: [u8; (N / 2) as Foo] = [0; (N / 2) as usize];
-   |                                   ^^^^^^^^^^^^^^^^^^^^^ expected `(N / 2) as Foo`, found `(N / 2) as usize`
-   |
-   = note: expected constant `(N / 2) as Foo`
-              found constant `(N / 2) as usize`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0308, E0391.
-For more information about an error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0391`.