From 234b9301087ac21dd1dec5e6cad59cb76346ee6c Mon Sep 17 00:00:00 2001 From: Mark Mansi Date: Sat, 28 Dec 2019 20:02:20 -0600 Subject: [PATCH] rename nonlexical_regioncx -> regioncx --- .../diagnostics/explain_borrow.rs | 15 +++------ .../borrow_check/diagnostics/region_errors.rs | 32 +++++++++---------- .../borrow_check/diagnostics/region_name.rs | 28 +++++++--------- src/librustc_mir/borrow_check/mod.rs | 7 ++-- 4 files changed, 34 insertions(+), 48 deletions(-) diff --git a/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs b/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs index 45c6c845cd156..ca5cf5bc741a0 100644 --- a/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs +++ b/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs @@ -260,17 +260,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { borrow_region: RegionVid, outlived_region: RegionVid, ) -> (ConstraintCategory, bool, Span, Option) { - let (category, from_closure, span) = self.nonlexical_regioncx.best_blame_constraint( + let (category, from_closure, span) = self.regioncx.best_blame_constraint( &self.body, borrow_region, NLLRegionVariableOrigin::FreeRegion, - |r| { - self.nonlexical_regioncx.provides_universal_region( - r, - borrow_region, - outlived_region, - ) - }, + |r| self.regioncx.provides_universal_region(r, borrow_region, outlived_region), ); let mut renctx = RegionErrorNamingCtx::new(); @@ -303,15 +297,14 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { location, borrow, kind_place ); - let regioncx = &self.nonlexical_regioncx; + let regioncx = &self.regioncx; let body: &Body<'_> = &self.body; let tcx = self.infcx.tcx; let borrow_region_vid = borrow.region; debug!("explain_why_borrow_contains_point: borrow_region_vid={:?}", borrow_region_vid); - let region_sub = - self.nonlexical_regioncx.find_sub_region_live_at(borrow_region_vid, location); + let region_sub = self.regioncx.find_sub_region_live_at(borrow_region_vid, location); debug!("explain_why_borrow_contains_point: region_sub={:?}", region_sub); match find_use::find(body, regioncx, tcx, region_sub, location) { diff --git a/src/librustc_mir/borrow_check/diagnostics/region_errors.rs b/src/librustc_mir/borrow_check/diagnostics/region_errors.rs index dcba790ad7e48..f3dc8e72e3016 100644 --- a/src/librustc_mir/borrow_check/diagnostics/region_errors.rs +++ b/src/librustc_mir/borrow_check/diagnostics/region_errors.rs @@ -112,19 +112,18 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { /// to find a good name from that. Returns `None` if we can't find /// one (e.g., this is just some random part of the CFG). pub(super) fn to_error_region(&self, r: RegionVid) -> Option> { - self.to_error_region_vid(r) - .and_then(|r| self.nonlexical_regioncx.region_definition(r).external_name) + self.to_error_region_vid(r).and_then(|r| self.regioncx.region_definition(r).external_name) } /// Returns the `RegionVid` corresponding to the region returned by /// `to_error_region`. pub(super) fn to_error_region_vid(&self, r: RegionVid) -> Option { - if self.nonlexical_regioncx.universal_regions().is_universal_region(r) { + if self.regioncx.universal_regions().is_universal_region(r) { Some(r) } else { - let upper_bound = self.nonlexical_regioncx.universal_upper_bound(r); + let upper_bound = self.regioncx.universal_upper_bound(r); - if self.nonlexical_regioncx.upper_bound_in_region_scc(r, upper_bound) { + if self.regioncx.upper_bound_in_region_scc(r, upper_bound) { self.to_error_region_vid(upper_bound) } else { None @@ -137,7 +136,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { if let Some(ty::ReFree(free_region)) = self.to_error_region(fr) { if let ty::BoundRegion::BrEnv = free_region.bound_region { if let DefiningTy::Closure(def_id, substs) = - self.nonlexical_regioncx.universal_regions().defining_ty + self.regioncx.universal_regions().defining_ty { let closure_kind_ty = substs.as_closure().kind_ty(def_id, self.infcx.tcx); return Some(ty::ClosureKind::FnMut) == closure_kind_ty.to_opt_closure_kind(); @@ -219,11 +218,10 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { fr_origin, error_element, } => { - let error_region = - self.nonlexical_regioncx.region_from_element(longer_fr, error_element); + let error_region = self.regioncx.region_from_element(longer_fr, error_element); // Find the code to blame for the fact that `longer_fr` outlives `error_fr`. - let (_, span) = self.nonlexical_regioncx.find_outlives_blame_span( + let (_, span) = self.regioncx.find_outlives_blame_span( &self.body, longer_fr, fr_origin, @@ -286,8 +284,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { debug!("report_error(fr={:?}, outlived_fr={:?})", fr, outlived_fr); let (category, _, span) = - self.nonlexical_regioncx.best_blame_constraint(&self.body, fr, fr_origin, |r| { - self.nonlexical_regioncx.provides_universal_region(r, fr, outlived_fr) + self.regioncx.best_blame_constraint(&self.body, fr, fr_origin, |r| { + self.regioncx.provides_universal_region(r, fr, outlived_fr) }); debug!("report_error: category={:?} {:?}", category, span); @@ -302,8 +300,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { } let (fr_is_local, outlived_fr_is_local): (bool, bool) = ( - self.nonlexical_regioncx.universal_regions().is_local_free_region(fr), - self.nonlexical_regioncx.universal_regions().is_local_free_region(outlived_fr), + self.regioncx.universal_regions().is_local_free_region(fr), + self.regioncx.universal_regions().is_local_free_region(outlived_fr), ); debug!( @@ -378,7 +376,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { // We should check if the return type of this closure is in fact a closure - in that // case, we can special case the error further. let return_type_is_closure = - self.nonlexical_regioncx.universal_regions().unnormalized_output_ty.is_closure(); + self.regioncx.universal_regions().unnormalized_output_ty.is_closure(); let message = if return_type_is_closure { "returns a closure that contains a reference to a captured variable, which then \ escapes the closure body" @@ -430,14 +428,14 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { ) -> DiagnosticBuilder<'tcx> { let ErrorConstraintInfo { span, category, .. } = errci; - let fr_name_and_span = self.nonlexical_regioncx.get_var_name_and_span_for_region( + let fr_name_and_span = self.regioncx.get_var_name_and_span_for_region( self.infcx.tcx, &self.body, &self.local_names, &self.upvars, errci.fr, ); - let outlived_fr_name_and_span = self.nonlexical_regioncx.get_var_name_and_span_for_region( + let outlived_fr_name_and_span = self.regioncx.get_var_name_and_span_for_region( self.infcx.tcx, &self.body, &self.local_names, @@ -445,7 +443,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { errci.outlived_fr, ); - let escapes_from = match self.nonlexical_regioncx.universal_regions().defining_ty { + let escapes_from = match self.regioncx.universal_regions().defining_ty { DefiningTy::Closure(..) => "closure", DefiningTy::Generator(..) => "generator", DefiningTy::FnDef(..) => "function", diff --git a/src/librustc_mir/borrow_check/diagnostics/region_name.rs b/src/librustc_mir/borrow_check/diagnostics/region_name.rs index b6bfa30b4dcdf..7ce29713240ce 100644 --- a/src/librustc_mir/borrow_check/diagnostics/region_name.rs +++ b/src/librustc_mir/borrow_check/diagnostics/region_name.rs @@ -191,7 +191,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { ) -> Option { debug!("give_region_a_name(fr={:?}, counter={:?})", fr, renctx.counter); - assert!(self.nonlexical_regioncx.universal_regions().is_universal_region(fr)); + assert!(self.regioncx.universal_regions().is_universal_region(fr)); if let Some(value) = renctx.get(&fr) { return Some(value.clone()); @@ -277,7 +277,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { .hir() .as_local_hir_id(self.mir_def_id) .expect("non-local mir"); - let def_ty = self.nonlexical_regioncx.universal_regions().defining_ty; + let def_ty = self.regioncx.universal_regions().defining_ty; if let DefiningTy::Closure(def_id, substs) = def_ty { let args_span = if let hir::ExprKind::Closure(_, _, _, span, _) = @@ -344,12 +344,10 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { fr: RegionVid, renctx: &mut RegionErrorNamingCtx, ) -> Option { - let implicit_inputs = - self.nonlexical_regioncx.universal_regions().defining_ty.implicit_inputs(); - let argument_index = - self.nonlexical_regioncx.get_argument_index_for_region(self.infcx.tcx, fr)?; + let implicit_inputs = self.regioncx.universal_regions().defining_ty.implicit_inputs(); + let argument_index = self.regioncx.get_argument_index_for_region(self.infcx.tcx, fr)?; - let arg_ty = self.nonlexical_regioncx.universal_regions().unnormalized_input_tys + let arg_ty = self.regioncx.universal_regions().unnormalized_input_tys [implicit_inputs + argument_index]; if let Some(region_name) = self.give_name_if_we_can_match_hir_ty_from_argument(fr, arg_ty, argument_index, renctx) @@ -415,10 +413,9 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { ); let assigned_region_name = if type_name.find(&format!("'{}", counter)).is_some() { // Only add a label if we can confirm that a region was labelled. - let argument_index = self - .nonlexical_regioncx - .get_argument_index_for_region(self.infcx.tcx, needle_fr)?; - let (_, span) = self.nonlexical_regioncx.get_argument_name_and_span_for_region( + let argument_index = + self.regioncx.get_argument_index_for_region(self.infcx.tcx, needle_fr)?; + let (_, span) = self.regioncx.get_argument_name_and_span_for_region( &self.body, &self.local_names, argument_index, @@ -658,9 +655,8 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { fr: RegionVid, renctx: &mut RegionErrorNamingCtx, ) -> Option { - let upvar_index = - self.nonlexical_regioncx.get_upvar_index_for_region(self.infcx.tcx, fr)?; - let (upvar_name, upvar_span) = self.nonlexical_regioncx.get_upvar_name_and_span_for_region( + let upvar_index = self.regioncx.get_upvar_index_for_region(self.infcx.tcx, fr)?; + let (upvar_name, upvar_span) = self.regioncx.get_upvar_name_and_span_for_region( self.infcx.tcx, &self.upvars, upvar_index, @@ -684,7 +680,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { ) -> Option { let tcx = self.infcx.tcx; - let return_ty = self.nonlexical_regioncx.universal_regions().unnormalized_output_ty; + let return_ty = self.regioncx.universal_regions().unnormalized_output_ty; debug!("give_name_if_anonymous_region_appears_in_output: return_ty = {:?}", return_ty); if !tcx.any_free_region_meets(&return_ty, |r| r.to_region_vid() == fr) { return None; @@ -734,7 +730,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { ) -> Option { // Note: generators from `async fn` yield `()`, so we don't have to // worry about them here. - let yield_ty = self.nonlexical_regioncx.universal_regions().yield_ty?; + let yield_ty = self.regioncx.universal_regions().yield_ty?; debug!("give_name_if_anonymous_region_appears_in_yield_ty: yield_ty = {:?}", yield_ty,); let tcx = self.infcx.tcx; diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 22037ac6c81b2..0ad9d4492b208 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -283,7 +283,7 @@ fn do_mir_borrowck<'a, 'tcx>( move_error_reported: BTreeMap::new(), uninitialized_error_reported: Default::default(), errors_buffer, - nonlexical_regioncx: regioncx, + regioncx, used_mut: Default::default(), used_mut_upvars: SmallVec::new(), borrow_set, @@ -474,10 +474,9 @@ crate struct MirBorrowckCtxt<'cx, 'tcx> { /// If the function we're checking is a closure, then we'll need to report back the list of /// mutable upvars that have been used. This field keeps track of them. used_mut_upvars: SmallVec<[Field; 8]>, - /// Non-lexical region inference context, if NLL is enabled. This - /// contains the results from region inference and lets us e.g. + /// Region inference context. This contains the results from region inference and lets us e.g. /// find out which CFG points are contained in each borrow region. - nonlexical_regioncx: Rc>, + regioncx: Rc>, /// The set of borrows extracted from the MIR borrow_set: Rc>,