From b9652aee6533378bc3116969f04551058d3667e9 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 26 Jul 2018 15:38:18 +0300 Subject: [PATCH] region_infer: rustfmt, pacifying the mercilous tidy --- .../borrow_check/nll/region_infer/mod.rs | 72 ++++++++++++------- 1 file changed, 48 insertions(+), 24 deletions(-) diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs index 6281b5dd4b6..afd4e2859ac 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs @@ -14,8 +14,8 @@ use borrow_check::nll::constraints::{ ConstraintIndex, ConstraintSccIndex, ConstraintSet, OutlivesConstraint, }; use borrow_check::nll::region_infer::values::{RegionElement, ToElementIndex}; -use borrow_check::nll::type_check::Locations; use borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations; +use borrow_check::nll::type_check::Locations; use rustc::hir::def_id::DefId; use rustc::infer::canonical::QueryRegionConstraint; use rustc::infer::region_constraints::{GenericKind, VarInfos}; @@ -313,8 +313,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { for (external_name, variable) in self.universal_regions.named_universal_regions() { debug!( "init_universal_regions: region {:?} has external name {:?}", - variable, - external_name + variable, external_name ); self.definitions[variable].external_name = Some(external_name); } @@ -424,10 +423,20 @@ impl<'tcx> RegionInferenceContext<'tcx> { }; self.check_type_tests( - infcx, mir, mir_def_id, outlives_requirements.as_mut(), errors_buffer); + infcx, + mir, + mir_def_id, + outlives_requirements.as_mut(), + errors_buffer, + ); self.check_universal_regions( - infcx, mir, mir_def_id, outlives_requirements.as_mut(), errors_buffer); + infcx, + mir, + mir_def_id, + outlives_requirements.as_mut(), + errors_buffer, + ); let outlives_requirements = outlives_requirements.unwrap_or(vec![]); @@ -586,13 +595,15 @@ impl<'tcx> RegionInferenceContext<'tcx> { if let Some(lower_bound_region) = lower_bound_region { let region_scope_tree = &tcx.region_scope_tree(mir_def_id); let type_test_span = type_test.locations.span(mir); - infcx.construct_generic_bound_failure( - region_scope_tree, - type_test_span, - None, - type_test.generic_kind, - lower_bound_region, - ).buffer(errors_buffer); + infcx + .construct_generic_bound_failure( + region_scope_tree, + type_test_span, + None, + type_test.generic_kind, + lower_bound_region, + ) + .buffer(errors_buffer); } else { // FIXME. We should handle this case better. It // indicates that we have e.g. some region variable @@ -604,10 +615,12 @@ impl<'tcx> RegionInferenceContext<'tcx> { // iterating over the universal regions and reporting // an error that multiple bounds are required. let type_test_span = type_test.locations.span(mir); - tcx.sess.struct_span_err( - type_test_span, - &format!("`{}` does not live long enough", type_test.generic_kind,), - ).buffer(errors_buffer); + tcx.sess + .struct_span_err( + type_test_span, + &format!("`{}` does not live long enough", type_test.generic_kind,), + ) + .buffer(errors_buffer); } } } @@ -659,8 +672,11 @@ impl<'tcx> RegionInferenceContext<'tcx> { // region, which ensures it can be encoded in a `ClosureOutlivesRequirement`. let lower_bound_plus = self.non_local_universal_upper_bound(*lower_bound); assert!(self.universal_regions.is_universal_region(lower_bound_plus)); - assert!(!self.universal_regions - .is_local_free_region(lower_bound_plus)); + assert!( + !self + .universal_regions + .is_local_free_region(lower_bound_plus) + ); propagated_outlives_requirements.push(ClosureOutlivesRequirement { subject, @@ -892,7 +908,8 @@ impl<'tcx> RegionInferenceContext<'tcx> { return true; } - self.scc_values.contains_points(sup_region_scc, sub_region_scc) + self.scc_values + .contains_points(sup_region_scc, sub_region_scc) } /// Once regions have been propagated, this method is used to see @@ -982,7 +999,10 @@ impl<'tcx> RegionInferenceContext<'tcx> { // (because `fr` includes `end(o)`). for shorter_fr in self.scc_values.universal_regions_outlived_by(longer_fr_scc) { // If it is known that `fr: o`, carry on. - if self.universal_region_relations.outlives(longer_fr, shorter_fr) { + if self + .universal_region_relations + .outlives(longer_fr, shorter_fr) + { continue; } @@ -996,14 +1016,19 @@ impl<'tcx> RegionInferenceContext<'tcx> { if let Some(propagated_outlives_requirements) = propagated_outlives_requirements { // Shrink `fr` until we find a non-local region (if we do). // We'll call that `fr-` -- it's ever so slightly smaller than `fr`. - if let Some(fr_minus) = self.universal_region_relations.non_local_lower_bound(longer_fr) { + if let Some(fr_minus) = self + .universal_region_relations + .non_local_lower_bound(longer_fr) + { debug!("check_universal_region: fr_minus={:?}", fr_minus); // Grow `shorter_fr` until we find a non-local // region. (We always will.) We'll call that // `shorter_fr+` -- it's ever so slightly larger than // `fr`. - let shorter_fr_plus = self.universal_region_relations.non_local_upper_bound(shorter_fr); + let shorter_fr_plus = self + .universal_region_relations + .non_local_upper_bound(shorter_fr); debug!( "check_universal_region: shorter_fr_plus={:?}", shorter_fr_plus @@ -1026,8 +1051,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { // Note: in this case, we use the unapproximated regions // to report the error. This gives better error messages // in some cases. - self.report_error( - mir, infcx, mir_def_id, longer_fr, shorter_fr, errors_buffer); + self.report_error(mir, infcx, mir_def_id, longer_fr, shorter_fr, errors_buffer); } }