Remove assertion now that we have a test covering the code path

compiler/rustc_infer/src/infer/mod.rs

@@ -957,19 +957,6 @@ impl<'tcx> InferCtxt<'tcx> {
             (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
                 return Err((a_vid, b_vid));
             }
-            // We don't silently want to constrain hidden types here, so we assert that either one side is
-            // an infer var, so it'll get constrained to whatever the other side is, or there are no opaque
-            // types involved.
-            // We don't expect this to actually get hit, but if it does, we now at least know how to write
-            // a test for it.
-            (_, ty::Infer(ty::TyVar(_))) => {}
-            (ty::Infer(ty::TyVar(_)), _) => {}
-            _ if r_a != r_b && (r_a, r_b).has_opaque_types() => {
-                span_bug!(
-                    cause.span(),
-                    "opaque types got hidden types registered from within subtype predicate: {r_a:?} vs {r_b:?}"
-                )
-            }
             _ => {}
         }
 

src/tools/compiletest/src/runtest.rs

@@ -381,7 +381,7 @@ impl<'test> TestCx<'test> {
         // if a test does not crash, consider it an error
         if proc_res.status.success() || matches!(proc_res.status.code(), Some(1 | 0)) {
             self.fatal(&format!(
-                "test no longer crashes/triggers ICE! Please give it a mearningful name, \
+                "test no longer crashes/triggers ICE! Please give it a meaningful name, \
             add a doc-comment to the start of the test explaining why it exists and \
             move it to tests/ui or wherever you see fit."
             ));

tests/ui/impl-trait/lazy_subtyping_of_opaques.rs

@@ -1,3 +1,7 @@
+//! This test checks that we allow subtyping predicates that contain opaque types.
+//! No hidden types are being constrained in the subtyping predicate, but type and
+//! lifetime variables get subtyped in the generic parameter list of the opaque.
+
 use std::iter;
 
 mod either {
@@ -24,11 +28,17 @@ impl<'a> BabeConsensusLogRef<'a> {
     pub fn scale_encoding(
         &self,
     ) -> impl Iterator<Item = impl AsRef<[u8]> + Clone + 'a> + Clone + 'a {
+        //~^ ERROR is not satisfied
+        //~| ERROR is not satisfied
+        //~| ERROR is not satisfied
         match self {
             BabeConsensusLogRef::NextEpochData(digest) => either::Left(either::Left(
                 digest.scale_encoding().map(either::Left).map(either::Left),
             )),
             BabeConsensusLogRef::NextConfigData => either::Right(
+                // The Opaque type from ``scale_encoding` gets used opaquely here, while the `R`
+                // generic parameter of `Either` contains type variables that get subtyped and the
+                // opaque type contains lifetime variables that get subtyped.
                 iter::once(either::Right(either::Left([1])))
                     .chain(std::iter::once([1]).map(either::Right).map(either::Right)),
             ),

tests/ui/impl-trait/lazy_subtyping_of_opaques.stderr

@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `Either<Either<Map<Map<impl Iterator<Item = impl AsRef<[u8]> + Clone + '_> + Clone + '_, fn(impl AsRef<[u8]> + Clone + '_) -> Either<impl AsRef<[u8]> + Clone + '_, _> {Either::<impl AsRef<[u8]> + Clone + '_, _>::Left}>, fn(Either<impl AsRef<[u8]> + Clone + '_, _>) -> Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>> {Either::<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>::Left}>, _>, std::iter::Chain<std::iter::Once<Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>>, Map<Map<std::iter::Once<[{integer}; 1]>, fn([{integer}; 1]) -> Either<[{integer}; 1], [{integer}; 1]> {Either::<[{integer}; 1], [{integer}; 1]>::Right}>, fn(Either<[{integer}; 1], [{integer}; 1]>) -> Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>> {Either::<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>::Right}>>>: Clone` is not satisfied
+  --> $DIR/lazy_subtyping_of_opaques.rs:30:10
+   |
+LL |     ) -> impl Iterator<Item = impl AsRef<[u8]> + Clone + 'a> + Clone + 'a {
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `Either<Either<Map<Map<impl Iterator<Item = impl AsRef<[u8]> + Clone + '_> + Clone + '_, fn(impl AsRef<[u8]> + Clone + '_) -> Either<impl AsRef<[u8]> + Clone + '_, _> {Either::<impl AsRef<[u8]> + Clone + '_, _>::Left}>, fn(Either<impl AsRef<[u8]> + Clone + '_, _>) -> Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>> {Either::<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>::Left}>, _>, std::iter::Chain<std::iter::Once<Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>>, Map<Map<std::iter::Once<[{integer}; 1]>, fn([{integer}; 1]) -> Either<[{integer}; 1], [{integer}; 1]> {Either::<[{integer}; 1], [{integer}; 1]>::Right}>, fn(Either<[{integer}; 1], [{integer}; 1]>) -> Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>> {Either::<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>::Right}>>>`
+
+error[E0277]: the trait bound `Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>: AsRef<[u8]>` is not satisfied
+  --> $DIR/lazy_subtyping_of_opaques.rs:30:31
+   |
+LL |     ) -> impl Iterator<Item = impl AsRef<[u8]> + Clone + 'a> + Clone + 'a {
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `AsRef<[u8]>` is not implemented for `Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>`
+
+error[E0277]: the trait bound `Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>: Clone` is not satisfied
+  --> $DIR/lazy_subtyping_of_opaques.rs:30:31
+   |
+LL |     ) -> impl Iterator<Item = impl AsRef<[u8]> + Clone + 'a> + Clone + 'a {
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `Either<Either<impl AsRef<[u8]> + Clone + '_, _>, Either<[{integer}; 1], [{integer}; 1]>>`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/type-alias-impl-trait/lazy_subtyping_of_opaques.rs

@@ -1,9 +1,16 @@
 #![feature(type_alias_impl_trait)]
 
+//! This test used to ICE rust-lang/rust#124891
+//! because we added an assertion for catching cases where opaque types get
+//! registered during the processing of subtyping predicates.
+
 type Tait = impl FnOnce() -> ();
 
 fn reify_as_tait() -> Thunk<Tait> {
-    Thunk::new(|cont| cont)
+    //~^ ERROR expected a `FnOnce()` closure, found `()`
+    Thunk::new(|cont| cont /* opaque type gets constrained to `()`` here */)
+    //~^ ERROR expected a `FnOnce()` closure, found `()`
+    //~| ERROR mismatched types
 }
 
 struct Thunk<F>(F);
@@ -20,3 +27,5 @@ impl<F> Thunk<F> {
 trait ContFn {}
 
 impl<F: FnOnce(Tait) -> ()> ContFn for F {}
+
+fn main() {}

tests/ui/type-alias-impl-trait/lazy_subtyping_of_opaques.stderr

@@ -0,0 +1,31 @@
+error[E0277]: expected a `FnOnce()` closure, found `()`
+  --> $DIR/lazy_subtyping_of_opaques.rs:11:23
+   |
+LL |     Thunk::new(|cont| cont /* opaque type gets constrained to `()`` here */)
+   |                       ^^^^ expected an `FnOnce()` closure, found `()`
+   |
+   = help: the trait `FnOnce<()>` is not implemented for `()`
+   = note: wrap the `()` in a closure with no arguments: `|| { /* code */ }`
+
+error[E0277]: expected a `FnOnce()` closure, found `()`
+  --> $DIR/lazy_subtyping_of_opaques.rs:9:23
+   |
+LL | fn reify_as_tait() -> Thunk<Tait> {
+   |                       ^^^^^^^^^^^ expected an `FnOnce()` closure, found `()`
+   |
+   = help: the trait `FnOnce<()>` is not implemented for `()`
+   = note: wrap the `()` in a closure with no arguments: `|| { /* code */ }`
+
+error[E0308]: mismatched types
+  --> $DIR/lazy_subtyping_of_opaques.rs:11:5
+   |
+LL |     Thunk::new(|cont| cont /* opaque type gets constrained to `()`` here */)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Thunk<_>`, found `()`
+   |
+   = note: expected struct `Thunk<_>`
+           found unit type `()`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.