From 893b919e64b59c04dbd7c88e74ba138ff8e22a64 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 23 Jun 2022 16:28:46 -0400 Subject: [PATCH] remove VerifyBound::IfEq variant --- .../rustc_borrowck/src/region_infer/mod.rs | 23 ------- .../src/infer/lexical_region_resolve/mod.rs | 5 -- .../src/infer/region_constraints/mod.rs | 64 +++++++++---------- 3 files changed, 32 insertions(+), 60 deletions(-) diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs index 4830eb3f464..56045166060 100644 --- a/compiler/rustc_borrowck/src/region_infer/mod.rs +++ b/compiler/rustc_borrowck/src/region_infer/mod.rs @@ -19,7 +19,6 @@ use rustc_middle::mir::{ }; use rustc_middle::traits::ObligationCause; use rustc_middle::traits::ObligationCauseCode; -use rustc_middle::ty::Region; use rustc_middle::ty::{self, subst::SubstsRef, RegionVid, Ty, TyCtxt, TypeFoldable}; use rustc_span::Span; @@ -1192,10 +1191,6 @@ impl<'tcx> RegionInferenceContext<'tcx> { debug!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound, verify_bound); match verify_bound { - VerifyBound::IfEq(test_ty, verify_bound1) => { - self.eval_if_eq(infcx, generic_ty, lower_bound, *test_ty, *verify_bound1) - } - VerifyBound::IfEqBound(verify_if_eq_b) => { self.eval_if_eq_bound(infcx, param_env, generic_ty, lower_bound, *verify_if_eq_b) } @@ -1234,24 +1229,6 @@ impl<'tcx> RegionInferenceContext<'tcx> { } } - fn eval_if_eq( - &self, - infcx: &InferCtxt<'_, 'tcx>, - generic_ty: Ty<'tcx>, - lower_bound: RegionVid, - test_ty: Ty<'tcx>, - verify_bound: Region<'tcx>, - ) -> bool { - let generic_ty_normalized = self.normalize_to_scc_representatives(infcx.tcx, generic_ty); - let test_ty_normalized = self.normalize_to_scc_representatives(infcx.tcx, test_ty); - if generic_ty_normalized == test_ty_normalized { - let verify_bound_vid = self.to_region_vid(verify_bound); - self.eval_outlives(verify_bound_vid, lower_bound) - } else { - false - } - } - fn eval_if_eq_bound( &self, infcx: &InferCtxt<'_, 'tcx>, diff --git a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs index 1cc5f3d53c9..51943f9f38c 100644 --- a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs +++ b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs @@ -822,11 +822,6 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> { min: ty::Region<'tcx>, ) -> bool { match bound { - VerifyBound::IfEq(k, r) => { - (var_values.normalize(self.region_rels.tcx, *k) == generic_ty) - && self.bound_is_met(&VerifyBound::OutlivedBy(*r), var_values, generic_ty, min) - } - VerifyBound::IfEqBound(verify_if_eq_b) => { match test_type_match::extract_verify_if_eq_bound( self.tcx(), diff --git a/compiler/rustc_infer/src/infer/region_constraints/mod.rs b/compiler/rustc_infer/src/infer/region_constraints/mod.rs index e0ccbb2c0f9..ab76f41414a 100644 --- a/compiler/rustc_infer/src/infer/region_constraints/mod.rs +++ b/compiler/rustc_infer/src/infer/region_constraints/mod.rs @@ -190,42 +190,44 @@ pub enum GenericKind<'tcx> { /// This is described with an `AnyRegion('a, 'b)` node. #[derive(Debug, Clone)] pub enum VerifyBound<'tcx> { - /// Given a kind K and a bound B, expands to a function like the - /// following, where `G` is the generic for which this verify - /// bound was created: + /// This is a "conditional bound" that checks the result of inference + /// and supplies a bound if it ended up being relevant. It's used in situations + /// like this: + /// + /// ```rust + /// fn foo<'a, 'b, T: SomeTrait<'a>> + /// where + /// >::Item: 'b + /// ``` + /// + /// If we have an obligation like `>::Item: 'c`, then + /// we don't know yet whether it suffices to show that `'b: 'c`. If `'?x` winds + /// up being equal to `'a`, then the where-clauses on function applies, and + /// in that case we can show `'b: 'c`. But if `'?x` winds up being something + /// else, the bound isn't relevant. + /// + /// More abstractly, this function takes a `Binder`. The binder + /// represents an existential binder -- i.e., if you have something like + /// + /// ```rust + /// where for<'a> ::Item: 'a + /// ``` + /// + /// then the `for<'a>` corresponds to the binder. The idea is that we have + /// to find some instantiation of `'a` that can make `>::Item` + /// equal to the final value of `G`, the generic we are checking. /// /// ```ignore (pseudo-rust) /// fn(min) -> bool { - /// if G == K { - /// B(min) - /// } else { - /// false + /// exists<'a> { + /// if G == K { + /// B(min) + /// } else { + /// false + /// } /// } /// } /// ``` - /// - /// In other words, if the generic `G` that we are checking is - /// equal to `K`, then check the associated verify bound - /// (otherwise, false). - /// - /// This is used when we have something in the environment that - /// may or may not be relevant, depending on the region inference - /// results. For example, we may have `where >::Item: 'b` in our where-clauses. If we are - /// generating the verify-bound for `>::Item`, then - /// this where-clause is only relevant if `'0` winds up inferred - /// to `'a`. - /// - /// So we would compile to a verify-bound like - /// - /// ```ignore (illustrative) - /// IfEq(>::Item, AnyRegion('a)) - /// ``` - /// - /// meaning, if the subject G is equal to `>::Item` - /// (after inference), and `'a: min`, then `G: min`. - IfEq(Ty<'tcx>, Region<'tcx>), - IfEqBound(ty::Binder<'tcx, VerifyIfEq<'tcx>>), /// Given a region `R`, expands to the function: @@ -805,7 +807,6 @@ impl<'tcx> GenericKind<'tcx> { impl<'tcx> VerifyBound<'tcx> { pub fn must_hold(&self) -> bool { match self { - VerifyBound::IfEq(..) => false, VerifyBound::IfEqBound(..) => false, VerifyBound::OutlivedBy(re) => re.is_static(), VerifyBound::IsEmpty => false, @@ -816,7 +817,6 @@ impl<'tcx> VerifyBound<'tcx> { pub fn cannot_hold(&self) -> bool { match self { - VerifyBound::IfEq(_, _) => false, VerifyBound::IfEqBound(..) => false, VerifyBound::IsEmpty => false, VerifyBound::OutlivedBy(_) => false,