From 92d65ab2e9d805824b69565129fa3780e50f121e Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 4 Feb 2015 10:48:29 -0500 Subject: [PATCH] Rename various things to "implications" --- src/librustc_typeck/check/implicator.rs | 40 +++++++++++------------ src/librustc_typeck/check/regionck.rs | 42 ++++++++++--------------- 2 files changed, 36 insertions(+), 46 deletions(-) diff --git a/src/librustc_typeck/check/implicator.rs b/src/librustc_typeck/check/implicator.rs index 209570585d2..5c4ca97ec8e 100644 --- a/src/librustc_typeck/check/implicator.rs +++ b/src/librustc_typeck/check/implicator.rs @@ -10,8 +10,6 @@ // #![warn(deprecated_mode)] -pub use self::WfConstraint::*; - use astconv::object_region_bounds; use middle::infer::GenericKind; use middle::subst::{ParamSpace, Subst, Substs}; @@ -24,37 +22,37 @@ use util::ppaux::Repr; // Helper functions related to manipulating region types. -pub enum WfConstraint<'tcx> { - RegionSubRegionConstraint(Option>, ty::Region, ty::Region), - RegionSubGenericConstraint(Option>, ty::Region, GenericKind<'tcx>), +pub enum Implication<'tcx> { + RegionSubRegion(Option>, ty::Region, ty::Region), + RegionSubGeneric(Option>, ty::Region, GenericKind<'tcx>), } -struct Wf<'a, 'tcx: 'a> { +struct Implicator<'a, 'tcx: 'a> { tcx: &'a ty::ctxt<'tcx>, stack: Vec<(ty::Region, Option>)>, - out: Vec>, + out: Vec>, } /// This routine computes the well-formedness constraints that must hold for the type `ty` to /// appear in a context with lifetime `outer_region` -pub fn region_wf_constraints<'tcx>( +pub fn implications<'tcx>( tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, outer_region: ty::Region) - -> Vec> + -> Vec> { let mut stack = Vec::new(); stack.push((outer_region, None)); - let mut wf = Wf { tcx: tcx, + let mut wf = Implicator { tcx: tcx, stack: stack, out: Vec::new() }; wf.accumulate_from_ty(ty); wf.out } -impl<'a, 'tcx> Wf<'a, 'tcx> { +impl<'a, 'tcx> Implicator<'a, 'tcx> { fn accumulate_from_ty(&mut self, ty: Ty<'tcx>) { - debug!("Wf::accumulate_from_ty(ty={})", + debug!("accumulate_from_ty(ty={})", ty.repr(self.tcx)); match ty.sty { @@ -197,7 +195,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { opt_ty: Option>, r_a: ty::Region, r_b: ty::Region) { - self.out.push(RegionSubRegionConstraint(opt_ty, r_a, r_b)); + self.out.push(Implication::RegionSubRegion(opt_ty, r_a, r_b)); } /// Pushes a constraint that `param_ty` must outlive the top region on the stack. @@ -211,7 +209,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { fn push_projection_constraint_from_top(&mut self, projection_ty: &ty::ProjectionTy<'tcx>) { let &(region, opt_ty) = self.stack.last().unwrap(); - self.out.push(RegionSubGenericConstraint( + self.out.push(Implication::RegionSubGeneric( opt_ty, region, GenericKind::Projection(projection_ty.clone()))); } @@ -220,7 +218,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { region: ty::Region, opt_ty: Option>, param_ty: ty::ParamTy) { - self.out.push(RegionSubGenericConstraint( + self.out.push(Implication::RegionSubGeneric( opt_ty, region, GenericKind::Param(param_ty))); } @@ -372,22 +370,22 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { for &r_d in &required_region_bounds { // Each of these is an instance of the `'c <= 'b` // constraint above - self.out.push(RegionSubRegionConstraint(Some(ty), r_d, r_c)); + self.out.push(Implication::RegionSubRegion(Some(ty), r_d, r_c)); } } } -impl<'tcx> Repr<'tcx> for WfConstraint<'tcx> { +impl<'tcx> Repr<'tcx> for Implication<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { match *self { - RegionSubRegionConstraint(_, ref r_a, ref r_b) => { - format!("RegionSubRegionConstraint({}, {})", + Implication::RegionSubRegion(_, ref r_a, ref r_b) => { + format!("RegionSubRegion({}, {})", r_a.repr(tcx), r_b.repr(tcx)) } - RegionSubGenericConstraint(_, ref r, ref p) => { - format!("RegionSubGenericConstraint({}, {})", + Implication::RegionSubGeneric(_, ref r, ref p) => { + format!("RegionSubGeneric({}, {})", r.repr(tcx), p.repr(tcx)) } diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 6b506337508..72ea0961e05 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -335,25 +335,21 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { debug!("relate_free_regions(t={})", ty.repr(tcx)); let body_scope = CodeExtent::from_node_id(body_id); let body_scope = ty::ReScope(body_scope); - let constraints = - implicator::region_wf_constraints( - tcx, - ty, - body_scope); - for constraint in &constraints { - debug!("constraint: {}", constraint.repr(tcx)); - match *constraint { - implicator::RegionSubRegionConstraint(_, + let implications = implicator::implications(tcx, ty, body_scope); + for implication in implications { + debug!("implication: {}", implication.repr(tcx)); + match implication { + implicator::Implication::RegionSubRegion(_, ty::ReFree(free_a), ty::ReFree(free_b)) => { tcx.region_maps.relate_free_regions(free_a, free_b); } - implicator::RegionSubRegionConstraint(_, + implicator::Implication::RegionSubRegion(_, ty::ReFree(free_a), ty::ReInfer(ty::ReVar(vid_b))) => { self.fcx.inh.infcx.add_given(free_a, vid_b); } - implicator::RegionSubRegionConstraint(..) => { + implicator::Implication::RegionSubRegion(..) => { // In principle, we could record (and take // advantage of) every relationship here, but // we are also free not to -- it simply means @@ -364,8 +360,8 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { // relationship that arises here, but // presently we do not.) } - implicator::RegionSubGenericConstraint(_, r_a, ref generic_b) => { - debug!("RegionSubGenericConstraint: {} <= {}", + implicator::Implication::RegionSubGeneric(_, r_a, ref generic_b) => { + debug!("RegionSubGeneric: {} <= {}", r_a.repr(tcx), generic_b.repr(tcx)); self.region_bound_pairs.push((r_a, generic_b.clone())); @@ -1481,25 +1477,21 @@ pub fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, ty.repr(rcx.tcx()), region.repr(rcx.tcx())); - let constraints = - implicator::region_wf_constraints( - rcx.tcx(), - ty, - region); - for constraint in &constraints { - debug!("constraint: {}", constraint.repr(rcx.tcx())); - match *constraint { - implicator::RegionSubRegionConstraint(None, r_a, r_b) => { + let implications = implicator::implications(rcx.tcx(), ty, region); + for implication in implications { + debug!("implication: {}", implication.repr(rcx.tcx())); + match implication { + implicator::Implication::RegionSubRegion(None, r_a, r_b) => { rcx.fcx.mk_subr(origin.clone(), r_a, r_b); } - implicator::RegionSubRegionConstraint(Some(ty), r_a, r_b) => { + implicator::Implication::RegionSubRegion(Some(ty), r_a, r_b) => { let o1 = infer::ReferenceOutlivesReferent(ty, origin.span()); rcx.fcx.mk_subr(o1, r_a, r_b); } - implicator::RegionSubGenericConstraint(None, r_a, ref generic_b) => { + implicator::Implication::RegionSubGeneric(None, r_a, ref generic_b) => { generic_must_outlive(rcx, origin.clone(), r_a, generic_b); } - implicator::RegionSubGenericConstraint(Some(ty), r_a, ref generic_b) => { + implicator::Implication::RegionSubGeneric(Some(ty), r_a, ref generic_b) => { let o1 = infer::ReferenceOutlivesReferent(ty, origin.span()); generic_must_outlive(rcx, o1, r_a, generic_b); }