From c86974d94f918578b3a2a0b6b858e97be611c0f7 Mon Sep 17 00:00:00 2001 From: Oli Scherer Date: Wed, 28 Feb 2024 09:54:44 +0000 Subject: [PATCH 1/2] test that fudging with opaque types is the same in the new solver --- ...=> hidden-type-is-opaque-2.default.stderr} | 4 +-- .../hidden-type-is-opaque-2.next.stderr | 31 +++++++++++++++++++ .../ui/impl-trait/hidden-type-is-opaque-2.rs | 2 ++ 3 files changed, 35 insertions(+), 2 deletions(-) rename tests/ui/impl-trait/{hidden-type-is-opaque-2.stderr => hidden-type-is-opaque-2.default.stderr} (90%) create mode 100644 tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr similarity index 90% rename from tests/ui/impl-trait/hidden-type-is-opaque-2.stderr rename to tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr index 39bf22142326a..01c5a553dc502 100644 --- a/tests/ui/impl-trait/hidden-type-is-opaque-2.stderr +++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr @@ -1,5 +1,5 @@ error[E0282]: type annotations needed - --> $DIR/hidden-type-is-opaque-2.rs:8:17 + --> $DIR/hidden-type-is-opaque-2.rs:10:17 | LL | Thunk::new(|mut cont| { | ^^^^^^^^ @@ -13,7 +13,7 @@ LL | Thunk::new(|mut cont: /* Type */| { | ++++++++++++ error[E0282]: type annotations needed - --> $DIR/hidden-type-is-opaque-2.rs:18:17 + --> $DIR/hidden-type-is-opaque-2.rs:20:17 | LL | Thunk::new(|mut cont| { | ^^^^^^^^ diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr new file mode 100644 index 0000000000000..01c5a553dc502 --- /dev/null +++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr @@ -0,0 +1,31 @@ +error[E0282]: type annotations needed + --> $DIR/hidden-type-is-opaque-2.rs:10:17 + | +LL | Thunk::new(|mut cont| { + | ^^^^^^^^ +LL | +LL | cont.reify_as(); + | ---- type must be known at this point + | +help: consider giving this closure parameter an explicit type + | +LL | Thunk::new(|mut cont: /* Type */| { + | ++++++++++++ + +error[E0282]: type annotations needed + --> $DIR/hidden-type-is-opaque-2.rs:20:17 + | +LL | Thunk::new(|mut cont| { + | ^^^^^^^^ +LL | +LL | cont.reify_as(); + | ---- type must be known at this point + | +help: consider giving this closure parameter an explicit type + | +LL | Thunk::new(|mut cont: /* Type */| { + | ++++++++++++ + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0282`. diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.rs b/tests/ui/impl-trait/hidden-type-is-opaque-2.rs index 212e7b1080216..78ac8363ba930 100644 --- a/tests/ui/impl-trait/hidden-type-is-opaque-2.rs +++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.rs @@ -1,6 +1,8 @@ // This doesn't work, because we don't flow information from opaque types // into function arguments via the function's generic parameters // FIXME(oli-obk): make `expected_inputs_for_expected_output` support this +//@ revisions: default next +//@[next] compile-flags: -Znext-solver #![feature(type_alias_impl_trait)] From 0bb2a6b7800a843a8853d608dee39f56ece89321 Mon Sep 17 00:00:00 2001 From: Oli Scherer Date: Wed, 28 Feb 2024 09:59:50 +0000 Subject: [PATCH 2/2] Now that inlining, mir validation and const eval all use reveal-all, we won't be constraining hidden types here anymore --- .../src/util/compare_types.rs | 25 +++---------------- 1 file changed, 3 insertions(+), 22 deletions(-) diff --git a/compiler/rustc_const_eval/src/util/compare_types.rs b/compiler/rustc_const_eval/src/util/compare_types.rs index 265ca0c7884ce..3ea54146fc787 100644 --- a/compiler/rustc_const_eval/src/util/compare_types.rs +++ b/compiler/rustc_const_eval/src/util/compare_types.rs @@ -4,7 +4,7 @@ //! other areas of the compiler as well. use rustc_infer::infer::TyCtxtInferExt; -use rustc_middle::traits::{DefiningAnchor, ObligationCause}; +use rustc_middle::traits::ObligationCause; use rustc_middle::ty::{ParamEnv, Ty, TyCtxt, Variance}; use rustc_trait_selection::traits::ObligationCtxt; @@ -33,9 +33,6 @@ pub fn is_equal_up_to_subtyping<'tcx>( /// When validating assignments, the variance should be `Covariant`. When checking /// during `MirPhase` >= `MirPhase::Runtime(RuntimePhase::Initial)` variance should be `Invariant` /// because we want to check for type equality. -/// -/// This mostly ignores opaque types as it can be used in constraining contexts -/// while still computing the final underlying type. pub fn relate_types<'tcx>( tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, @@ -47,8 +44,7 @@ pub fn relate_types<'tcx>( return true; } - let mut builder = - tcx.infer_ctxt().ignoring_regions().with_opaque_type_inference(DefiningAnchor::Bubble); + let mut builder = tcx.infer_ctxt().ignoring_regions(); let infcx = builder.build(); let ocx = ObligationCtxt::new(&infcx); let cause = ObligationCause::dummy(); @@ -58,20 +54,5 @@ pub fn relate_types<'tcx>( Ok(()) => {} Err(_) => return false, }; - let errors = ocx.select_all_or_error(); - // With `Reveal::All`, opaque types get normalized away, with `Reveal::UserFacing` - // we would get unification errors because we're unable to look into opaque types, - // even if they're constrained in our current function. - for (key, ty) in infcx.take_opaque_types() { - let hidden_ty = tcx.type_of(key.def_id).instantiate(tcx, key.args); - if hidden_ty != ty.hidden_type.ty { - span_bug!( - ty.hidden_type.span, - "{}, {}", - tcx.type_of(key.def_id).instantiate(tcx, key.args), - ty.hidden_type.ty - ); - } - } - errors.is_empty() + ocx.select_all_or_error().is_empty() }