Rollup merge of rust-lang#125489 - oli-obk:revert_stuff_2, r=compiler…

…-errors

Revert problematic opaque type change

fixes rust-lang#124891
fixes rust-lang#125192

reverts rust-lang#123979

compiler/rustc_infer/src/infer/mod.rs

@@ -957,27 +957,14 @@ 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:?}"
- )
- }
  _ => {}
  }
 
  self.enter_forall(predicate, |ty::SubtypePredicate { a_is_expected, a, b }| {
  if a_is_expected {
- Ok(self.at(cause, param_env).sub(DefineOpaqueTypes::Yes, a, b))
+ Ok(self.at(cause, param_env).sub(DefineOpaqueTypes::No, a, b))
  } else {
- Ok(self.at(cause, param_env).sup(DefineOpaqueTypes::Yes, b, a))
+ Ok(self.at(cause, param_env).sup(DefineOpaqueTypes::No, b, a))
  }
  })
  }

tests/ui/impl-trait/lazy_subtyping_of_opaques.rs

@@ -0,0 +1,59 @@
+//! 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 {
+ pub enum Either<L, R> {
+ Left(L),
+ Right(R),
+ }
+
+ impl<L: Iterator, R: Iterator<Item = L::Item>> Iterator for Either<L, R> {
+ type Item = L::Item;
+ fn next(&mut self) -> Option<Self::Item> {
+ todo!()
+ }
+ }
+ pub use self::Either::{Left, Right};
+}
+
+pub enum BabeConsensusLogRef<'a> {
+ NextEpochData(BabeNextEpochRef<'a>),
+ NextConfigData,
+}
+
+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)),
+ ),
+ }
+ }
+}
+
+pub struct BabeNextEpochRef<'a>(&'a ());
+
+impl<'a> BabeNextEpochRef<'a> {
+ pub fn scale_encoding(
+ &self,
+ ) -> impl Iterator<Item = impl AsRef<[u8]> + Clone + 'a> + Clone + 'a {
+ std::iter::once([1])
+ }
+}
+
+fn main() {}

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

@@ -0,0 +1,30 @@
+#![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: mismatched types
+ //~| ERROR: mismatched types
+}
+
+struct Thunk<F>(F);
+
+impl<F> Thunk<F> {
+ fn new(f: F)
+ where
+ F: ContFn,
+ {
+ todo!();
+ }
+}
+
+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,26 @@
+error[E0308]: mismatched types
+ --> $DIR/lazy_subtyping_of_opaques.rs:10:23
+ |
+LL | type Tait = impl FnOnce() -> ();
+ | ------------------- the found opaque type
+...
+LL | Thunk::new(|cont| cont)
+ | ^^^^ expected `()`, found opaque type
+ |
+ = note: expected unit type `()`
+ found opaque type `Tait`
+
+error[E0308]: mismatched types
+ --> $DIR/lazy_subtyping_of_opaques.rs:10:5
+ |
+LL | fn reify_as_tait() -> Thunk<Tait> {
+ | ----------- expected `Thunk<_>` because of return type
+LL | Thunk::new(|cont| cont)
+ | ^^^^^^^^^^^^^^^^^^^^^^^ expected `Thunk<_>`, found `()`
+ |
+ = note: expected struct `Thunk<_>`
+ found unit type `()`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.