diff options
Diffstat (limited to 'compiler/rustc_borrowck')
29 files changed, 217 insertions, 199 deletions
diff --git a/compiler/rustc_borrowck/src/borrow_set.rs b/compiler/rustc_borrowck/src/borrow_set.rs index 7c921b85058..c7d0e336133 100644 --- a/compiler/rustc_borrowck/src/borrow_set.rs +++ b/compiler/rustc_borrowck/src/borrow_set.rs @@ -29,7 +29,7 @@ pub struct BorrowSet<'tcx> { /// Map from local to all the borrows on that local. pub local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>, - crate locals_state_at_exit: LocalsStateAtExit, + pub(crate) locals_state_at_exit: LocalsStateAtExit, } impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> { @@ -148,23 +148,23 @@ impl<'tcx> BorrowSet<'tcx> { } } - crate fn activations_at_location(&self, location: Location) -> &[BorrowIndex] { + pub(crate) fn activations_at_location(&self, location: Location) -> &[BorrowIndex] { self.activation_map.get(&location).map_or(&[], |activations| &activations[..]) } - crate fn len(&self) -> usize { + pub(crate) fn len(&self) -> usize { self.location_map.len() } - crate fn indices(&self) -> impl Iterator<Item = BorrowIndex> { + pub(crate) fn indices(&self) -> impl Iterator<Item = BorrowIndex> { BorrowIndex::from_usize(0)..BorrowIndex::from_usize(self.len()) } - crate fn iter_enumerated(&self) -> impl Iterator<Item = (BorrowIndex, &BorrowData<'tcx>)> { + pub(crate) fn iter_enumerated(&self) -> impl Iterator<Item = (BorrowIndex, &BorrowData<'tcx>)> { self.indices().zip(self.location_map.values()) } - crate fn get_index_of(&self, location: &Location) -> Option<BorrowIndex> { + pub(crate) fn get_index_of(&self, location: &Location) -> Option<BorrowIndex> { self.location_map.get_index_of(location).map(BorrowIndex::from) } } diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs index 70f7f1e493e..a1233d62cb0 100644 --- a/compiler/rustc_borrowck/src/borrowck_errors.rs +++ b/compiler/rustc_borrowck/src/borrowck_errors.rs @@ -3,7 +3,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span; impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { - crate fn cannot_move_when_borrowed( + pub(crate) fn cannot_move_when_borrowed( &self, span: Span, desc: &str, @@ -11,7 +11,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { struct_span_err!(self, span, E0505, "cannot move out of {} because it is borrowed", desc,) } - crate fn cannot_use_when_mutably_borrowed( + pub(crate) fn cannot_use_when_mutably_borrowed( &self, span: Span, desc: &str, @@ -31,7 +31,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_act_on_uninitialized_variable( + pub(crate) fn cannot_act_on_uninitialized_variable( &self, span: Span, verb: &str, @@ -47,7 +47,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { ) } - crate fn cannot_mutably_borrow_multiply( + pub(crate) fn cannot_mutably_borrow_multiply( &self, new_loan_span: Span, desc: &str, @@ -97,7 +97,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_uniquely_borrow_by_two_closures( + pub(crate) fn cannot_uniquely_borrow_by_two_closures( &self, new_loan_span: Span, desc: &str, @@ -126,7 +126,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_uniquely_borrow_by_one_closure( + pub(crate) fn cannot_uniquely_borrow_by_one_closure( &self, new_loan_span: Span, container_name: &str, @@ -157,7 +157,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_reborrow_already_uniquely_borrowed( + pub(crate) fn cannot_reborrow_already_uniquely_borrowed( &self, new_loan_span: Span, container_name: &str, @@ -193,7 +193,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_reborrow_already_borrowed( + pub(crate) fn cannot_reborrow_already_borrowed( &self, span: Span, desc_new: &str, @@ -242,7 +242,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_assign_to_borrowed( + pub(crate) fn cannot_assign_to_borrowed( &self, span: Span, borrow_span: Span, @@ -261,7 +261,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_reassign_immutable( + pub(crate) fn cannot_reassign_immutable( &self, span: Span, desc: &str, @@ -271,7 +271,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { struct_span_err!(self, span, E0384, "cannot assign {} {}", msg, desc) } - crate fn cannot_assign( + pub(crate) fn cannot_assign( &self, span: Span, desc: &str, @@ -279,7 +279,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { struct_span_err!(self, span, E0594, "cannot assign to {}", desc) } - crate fn cannot_move_out_of( + pub(crate) fn cannot_move_out_of( &self, move_from_span: Span, move_from_desc: &str, @@ -290,7 +290,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { /// Signal an error due to an attempt to move out of the interior /// of an array or slice. `is_index` is None when error origin /// didn't capture whether there was an indexing operation or not. - crate fn cannot_move_out_of_interior_noncopy( + pub(crate) fn cannot_move_out_of_interior_noncopy( &self, move_from_span: Span, ty: Ty<'_>, @@ -313,7 +313,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_move_out_of_interior_of_drop( + pub(crate) fn cannot_move_out_of_interior_of_drop( &self, move_from_span: Span, container_ty: Ty<'_>, @@ -329,7 +329,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_act_on_moved_value( + pub(crate) fn cannot_act_on_moved_value( &self, use_span: Span, verb: &str, @@ -349,7 +349,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { ) } - crate fn cannot_borrow_path_as_mutable_because( + pub(crate) fn cannot_borrow_path_as_mutable_because( &self, span: Span, path: &str, @@ -358,7 +358,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { struct_span_err!(self, span, E0596, "cannot borrow {} as mutable{}", path, reason,) } - crate fn cannot_mutate_in_immutable_section( + pub(crate) fn cannot_mutate_in_immutable_section( &self, mutate_span: Span, immutable_span: Span, @@ -380,7 +380,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_borrow_across_generator_yield( + pub(crate) fn cannot_borrow_across_generator_yield( &self, span: Span, yield_span: Span, @@ -395,7 +395,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_borrow_across_destructor( + pub(crate) fn cannot_borrow_across_destructor( &self, borrow_span: Span, ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { @@ -407,7 +407,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { ) } - crate fn path_does_not_live_long_enough( + pub(crate) fn path_does_not_live_long_enough( &self, span: Span, path: &str, @@ -415,7 +415,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { struct_span_err!(self, span, E0597, "{} does not live long enough", path,) } - crate fn cannot_return_reference_to_local( + pub(crate) fn cannot_return_reference_to_local( &self, span: Span, return_kind: &str, @@ -440,7 +440,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn cannot_capture_in_long_lived_closure( + pub(crate) fn cannot_capture_in_long_lived_closure( &self, closure_span: Span, closure_kind: &str, @@ -462,14 +462,14 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { err } - crate fn thread_local_value_does_not_live_long_enough( + pub(crate) fn thread_local_value_does_not_live_long_enough( &self, span: Span, ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { struct_span_err!(self, span, E0712, "thread-local variable borrowed past end of function",) } - crate fn temporary_value_borrowed_for_too_long( + pub(crate) fn temporary_value_borrowed_for_too_long( &self, span: Span, ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { @@ -486,7 +486,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { } } -crate fn borrowed_data_escapes_closure<'tcx>( +pub(crate) fn borrowed_data_escapes_closure<'tcx>( tcx: TyCtxt<'tcx>, escape_span: Span, escapes_from: &str, diff --git a/compiler/rustc_borrowck/src/constraints/graph.rs b/compiler/rustc_borrowck/src/constraints/graph.rs index c19a39c393f..609fbc2bc15 100644 --- a/compiler/rustc_borrowck/src/constraints/graph.rs +++ b/compiler/rustc_borrowck/src/constraints/graph.rs @@ -13,19 +13,19 @@ use crate::{ /// The construct graph organizes the constraints by their end-points. /// It can be used to view a `R1: R2` constraint as either an edge `R1 /// -> R2` or `R2 -> R1` depending on the direction type `D`. -crate struct ConstraintGraph<D: ConstraintGraphDirecton> { +pub(crate) struct ConstraintGraph<D: ConstraintGraphDirecton> { _direction: D, first_constraints: IndexVec<RegionVid, Option<OutlivesConstraintIndex>>, next_constraints: IndexVec<OutlivesConstraintIndex, Option<OutlivesConstraintIndex>>, } -crate type NormalConstraintGraph = ConstraintGraph<Normal>; +pub(crate) type NormalConstraintGraph = ConstraintGraph<Normal>; -crate type ReverseConstraintGraph = ConstraintGraph<Reverse>; +pub(crate) type ReverseConstraintGraph = ConstraintGraph<Reverse>; /// Marker trait that controls whether a `R1: R2` constraint /// represents an edge `R1 -> R2` or `R2 -> R1`. -crate trait ConstraintGraphDirecton: Copy + 'static { +pub(crate) trait ConstraintGraphDirecton: Copy + 'static { fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid; fn end_region(c: &OutlivesConstraint<'_>) -> RegionVid; fn is_normal() -> bool; @@ -36,7 +36,7 @@ crate trait ConstraintGraphDirecton: Copy + 'static { /// inference. This is because we compute the value of R1 by union'ing /// all the things that it relies on. #[derive(Copy, Clone, Debug)] -crate struct Normal; +pub(crate) struct Normal; impl ConstraintGraphDirecton for Normal { fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid { @@ -57,7 +57,7 @@ impl ConstraintGraphDirecton for Normal { /// we wish to iterate from a region (e.g., R2) to all the regions /// that will outlive it (e.g., R1). #[derive(Copy, Clone, Debug)] -crate struct Reverse; +pub(crate) struct Reverse; impl ConstraintGraphDirecton for Reverse { fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid { @@ -78,7 +78,11 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> { /// R2` is treated as an edge `R1 -> R2`. We use this graph to /// construct SCCs for region inference but also for error /// reporting. - crate fn new(direction: D, set: &OutlivesConstraintSet<'_>, num_region_vars: usize) -> Self { + pub(crate) fn new( + direction: D, + set: &OutlivesConstraintSet<'_>, + num_region_vars: usize, + ) -> Self { let mut first_constraints = IndexVec::from_elem_n(None, num_region_vars); let mut next_constraints = IndexVec::from_elem(None, &set.outlives); @@ -96,7 +100,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> { /// Given the constraint set from which this graph was built /// creates a region graph so that you can iterate over *regions* /// and not constraints. - crate fn region_graph<'rg, 'tcx>( + pub(crate) fn region_graph<'rg, 'tcx>( &'rg self, set: &'rg OutlivesConstraintSet<'tcx>, static_region: RegionVid, @@ -105,7 +109,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> { } /// Given a region `R`, iterate over all constraints `R: R1`. - crate fn outgoing_edges<'a, 'tcx>( + pub(crate) fn outgoing_edges<'a, 'tcx>( &'a self, region_sup: RegionVid, constraints: &'a OutlivesConstraintSet<'tcx>, @@ -129,7 +133,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> { } } -crate struct Edges<'s, 'tcx, D: ConstraintGraphDirecton> { +pub(crate) struct Edges<'s, 'tcx, D: ConstraintGraphDirecton> { graph: &'s ConstraintGraph<D>, constraints: &'s OutlivesConstraintSet<'tcx>, pointer: Option<OutlivesConstraintIndex>, @@ -169,7 +173,7 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> Iterator for Edges<'s, 'tcx, D> { /// This struct brings together a constraint set and a (normal, not /// reverse) constraint graph. It implements the graph traits and is /// usd for doing the SCC computation. -crate struct RegionGraph<'s, 'tcx, D: ConstraintGraphDirecton> { +pub(crate) struct RegionGraph<'s, 'tcx, D: ConstraintGraphDirecton> { set: &'s OutlivesConstraintSet<'tcx>, constraint_graph: &'s ConstraintGraph<D>, static_region: RegionVid, @@ -180,7 +184,7 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> RegionGraph<'s, 'tcx, D> { /// R2` is treated as an edge `R1 -> R2`. We use this graph to /// construct SCCs for region inference but also for error /// reporting. - crate fn new( + pub(crate) fn new( set: &'s OutlivesConstraintSet<'tcx>, constraint_graph: &'s ConstraintGraph<D>, static_region: RegionVid, @@ -190,14 +194,14 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> RegionGraph<'s, 'tcx, D> { /// Given a region `R`, iterate over all regions `R1` such that /// there exists a constraint `R: R1`. - crate fn outgoing_regions(&self, region_sup: RegionVid) -> Successors<'s, 'tcx, D> { + pub(crate) fn outgoing_regions(&self, region_sup: RegionVid) -> Successors<'s, 'tcx, D> { Successors { edges: self.constraint_graph.outgoing_edges(region_sup, self.set, self.static_region), } } } -crate struct Successors<'s, 'tcx, D: ConstraintGraphDirecton> { +pub(crate) struct Successors<'s, 'tcx, D: ConstraintGraphDirecton> { edges: Edges<'s, 'tcx, D>, } diff --git a/compiler/rustc_borrowck/src/constraints/mod.rs b/compiler/rustc_borrowck/src/constraints/mod.rs index 14f0e5f620a..6d5466c0c41 100644 --- a/compiler/rustc_borrowck/src/constraints/mod.rs +++ b/compiler/rustc_borrowck/src/constraints/mod.rs @@ -8,19 +8,19 @@ use std::ops::Index; use crate::type_check::Locations; -crate mod graph; +pub(crate) mod graph; /// A set of NLL region constraints. These include "outlives" /// constraints of the form `R1: R2`. Each constraint is identified by /// a unique `OutlivesConstraintIndex` and you can index into the set /// (`constraint_set[i]`) to access the constraint details. #[derive(Clone, Default)] -crate struct OutlivesConstraintSet<'tcx> { +pub(crate) struct OutlivesConstraintSet<'tcx> { outlives: IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>>, } impl<'tcx> OutlivesConstraintSet<'tcx> { - crate fn push(&mut self, constraint: OutlivesConstraint<'tcx>) { + pub(crate) fn push(&mut self, constraint: OutlivesConstraint<'tcx>) { debug!( "OutlivesConstraintSet::push({:?}: {:?} @ {:?}", constraint.sup, constraint.sub, constraint.locations @@ -38,20 +38,20 @@ impl<'tcx> OutlivesConstraintSet<'tcx> { /// N.B., this graph contains a "frozen" view of the current /// constraints. Any new constraints added to the `OutlivesConstraintSet` /// after the graph is built will not be present in the graph. - crate fn graph(&self, num_region_vars: usize) -> graph::NormalConstraintGraph { + pub(crate) fn graph(&self, num_region_vars: usize) -> graph::NormalConstraintGraph { graph::ConstraintGraph::new(graph::Normal, self, num_region_vars) } /// Like `graph`, but constraints a reverse graph where `R1: R2` /// represents an edge `R2 -> R1`. - crate fn reverse_graph(&self, num_region_vars: usize) -> graph::ReverseConstraintGraph { + pub(crate) fn reverse_graph(&self, num_region_vars: usize) -> graph::ReverseConstraintGraph { graph::ConstraintGraph::new(graph::Reverse, self, num_region_vars) } /// Computes cycles (SCCs) in the graph of regions. In particular, /// find all regions R1, R2 such that R1: R2 and R2: R1 and group /// them into an SCC, and find the relationships between SCCs. - crate fn compute_sccs( + pub(crate) fn compute_sccs( &self, constraint_graph: &graph::NormalConstraintGraph, static_region: RegionVid, @@ -60,7 +60,7 @@ impl<'tcx> OutlivesConstraintSet<'tcx> { Sccs::new(region_graph) } - crate fn outlives(&self) -> &IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>> { + pub(crate) fn outlives(&self) -> &IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>> { &self.outlives } } diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs index 5252b0b50c3..97d5a8d158e 100644 --- a/compiler/rustc_borrowck/src/dataflow.rs +++ b/compiler/rustc_borrowck/src/dataflow.rs @@ -233,7 +233,7 @@ impl<'tcx> OutOfScopePrecomputer<'_, 'tcx> { } impl<'a, 'tcx> Borrows<'a, 'tcx> { - crate fn new( + pub(crate) fn new( tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, nonlexical_regioncx: &'a RegionInferenceContext<'tcx>, diff --git a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs index 8601fbe27f3..07f182102f3 100644 --- a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs @@ -22,7 +22,7 @@ use crate::region_infer::values::RegionElement; use crate::MirBorrowckCtxt; #[derive(Clone)] -crate struct UniverseInfo<'tcx>(UniverseInfoInner<'tcx>); +pub(crate) struct UniverseInfo<'tcx>(UniverseInfoInner<'tcx>); /// What operation a universe was created for. #[derive(Clone)] @@ -36,15 +36,15 @@ enum UniverseInfoInner<'tcx> { } impl<'tcx> UniverseInfo<'tcx> { - crate fn other() -> UniverseInfo<'tcx> { + pub(crate) fn other() -> UniverseInfo<'tcx> { UniverseInfo(UniverseInfoInner::Other) } - crate fn relate(expected: Ty<'tcx>, found: Ty<'tcx>) -> UniverseInfo<'tcx> { + pub(crate) fn relate(expected: Ty<'tcx>, found: Ty<'tcx>) -> UniverseInfo<'tcx> { UniverseInfo(UniverseInfoInner::RelateTys { expected, found }) } - crate fn report_error( + pub(crate) fn report_error( &self, mbcx: &mut MirBorrowckCtxt<'_, 'tcx>, placeholder: ty::PlaceholderRegion, @@ -76,7 +76,7 @@ impl<'tcx> UniverseInfo<'tcx> { } } -crate trait ToUniverseInfo<'tcx> { +pub(crate) trait ToUniverseInfo<'tcx> { fn to_universe_info(self, base_universe: ty::UniverseIndex) -> UniverseInfo<'tcx>; } diff --git a/compiler/rustc_borrowck/src/diagnostics/find_use.rs b/compiler/rustc_borrowck/src/diagnostics/find_use.rs index 22e7cd9e52c..06fca4db0cf 100644 --- a/compiler/rustc_borrowck/src/diagnostics/find_use.rs +++ b/compiler/rustc_borrowck/src/diagnostics/find_use.rs @@ -11,7 +11,7 @@ use rustc_middle::mir::visit::{MirVisitable, PlaceContext, Visitor}; use rustc_middle::mir::{Body, Local, Location}; use rustc_middle::ty::{RegionVid, TyCtxt}; -crate fn find<'tcx>( +pub(crate) fn find<'tcx>( body: &Body<'tcx>, regioncx: &Rc<RegionInferenceContext<'tcx>>, tcx: TyCtxt<'tcx>, diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs index 05d29503180..9581bb65236 100644 --- a/compiler/rustc_borrowck/src/diagnostics/mod.rs +++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs @@ -35,12 +35,12 @@ mod move_errors; mod mutability_errors; mod region_errors; -crate use bound_region_errors::{ToUniverseInfo, UniverseInfo}; -crate use mutability_errors::AccessKind; -crate use outlives_suggestion::OutlivesSuggestionBuilder; -crate use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors}; -crate use region_name::{RegionName, RegionNameSource}; -crate use rustc_const_eval::util::CallKind; +pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo}; +pub(crate) use mutability_errors::AccessKind; +pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder; +pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors}; +pub(crate) use region_name::{RegionName, RegionNameSource}; +pub(crate) use rustc_const_eval::util::CallKind; use rustc_middle::mir::tcx::PlaceTy; pub(super) struct IncludingDowncast(pub(super) bool); diff --git a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs index ab9c206a46f..1688d1259fa 100644 --- a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs +++ b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs @@ -149,7 +149,7 @@ impl OutlivesSuggestionBuilder { } /// Add the outlives constraint `fr: outlived_fr` to the set of constraints we need to suggest. - crate fn collect_constraint(&mut self, fr: RegionVid, outlived_fr: RegionVid) { + pub(crate) fn collect_constraint(&mut self, fr: RegionVid, outlived_fr: RegionVid) { debug!("Collected {:?}: {:?}", fr, outlived_fr); // Add to set of constraints for final help note. @@ -158,7 +158,7 @@ impl OutlivesSuggestionBuilder { /// Emit an intermediate note on the given `Diagnostic` if the involved regions are /// suggestable. - crate fn intermediate_suggestion( + pub(crate) fn intermediate_suggestion( &mut self, mbcx: &MirBorrowckCtxt<'_, '_>, errci: &ErrorConstraintInfo, @@ -179,7 +179,7 @@ impl OutlivesSuggestionBuilder { /// If there is a suggestion to emit, add a diagnostic to the buffer. This is the final /// suggestion including all collected constraints. - crate fn add_suggestion(&self, mbcx: &mut MirBorrowckCtxt<'_, '_>) { + pub(crate) fn add_suggestion(&self, mbcx: &mut MirBorrowckCtxt<'_, '_>) { // No constraints to add? Done. if self.constraints_to_add.is_empty() { debug!("No constraints to suggest."); diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs index 6f1c8daf42e..f2b5c83c5c1 100644 --- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs @@ -58,10 +58,10 @@ impl ConstraintDescription for ConstraintCategory { /// /// Usually we expect this to either be empty or contain a small number of items, so we can avoid /// allocation most of the time. -crate type RegionErrors<'tcx> = Vec<RegionErrorKind<'tcx>>; +pub(crate) type RegionErrors<'tcx> = Vec<RegionErrorKind<'tcx>>; #[derive(Clone, Debug)] -crate enum RegionErrorKind<'tcx> { +pub(crate) enum RegionErrorKind<'tcx> { /// A generic bound failure for a type test (`T: 'a`). TypeTestError { type_test: TypeTest<'tcx> }, diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs index c4cef5710ae..4d2a16aa609 100644 --- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs +++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs @@ -15,18 +15,18 @@ use crate::{nll::ToRegionVid, universal_regions::DefiningTy, MirBorrowckCtxt}; /// A name for a particular region used in emitting diagnostics. This name could be a generated /// name like `'1`, a name used by the user like `'a`, or a name like `'static`. #[derive(Debug, Clone)] -crate struct RegionName { +pub(crate) struct RegionName { /// The name of the region (interned). - crate name: Symbol, + pub(crate) name: Symbol, /// Where the region comes from. - crate source: RegionNameSource, + pub(crate) source: RegionNameSource, } /// Denotes the source of a region that is named by a `RegionName`. For example, a free region that /// was named by the user would get `NamedFreeRegion` and `'static` lifetime would get `Static`. /// This helps to print the right kinds of diagnostics. #[derive(Debug, Clone)] -crate enum RegionNameSource { +pub(crate) enum RegionNameSource { /// A bound (not free) region that was substituted at the def site (not an HRTB). NamedEarlyBoundRegion(Span), /// A free region that the user has a name (`'a`) for. @@ -50,7 +50,7 @@ crate enum RegionNameSource { /// Describes what to highlight to explain to the user that we're giving an anonymous region a /// synthesized name, and how to highlight it. #[derive(Debug, Clone)] -crate enum RegionNameHighlight { +pub(crate) enum RegionNameHighlight { /// The anonymous region corresponds to a reference that was found by traversing the type in the HIR. MatchedHirTy(Span), /// The anonymous region corresponds to a `'_` in the generics list of a struct/enum/union. @@ -65,7 +65,7 @@ crate enum RegionNameHighlight { } impl RegionName { - crate fn was_named(&self) -> bool { + pub(crate) fn was_named(&self) -> bool { match self.source { RegionNameSource::NamedEarlyBoundRegion(..) | RegionNameSource::NamedFreeRegion(..) @@ -79,7 +79,7 @@ impl RegionName { } } - crate fn span(&self) -> Option<Span> { + pub(crate) fn span(&self) -> Option<Span> { match self.source { RegionNameSource::Static => None, RegionNameSource::NamedEarlyBoundRegion(span) @@ -98,7 +98,7 @@ impl RegionName { } } - crate fn highlight_region_name(&self, diag: &mut Diagnostic) { + pub(crate) fn highlight_region_name(&self, diag: &mut Diagnostic) { match &self.source { RegionNameSource::NamedFreeRegion(span) | RegionNameSource::NamedEarlyBoundRegion(span) => { @@ -178,11 +178,11 @@ impl Display for RegionName { } impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { - crate fn mir_def_id(&self) -> hir::def_id::LocalDefId { + pub(crate) fn mir_def_id(&self) -> hir::def_id::LocalDefId { self.body.source.def_id().as_local().unwrap() } - crate fn mir_hir_id(&self) -> hir::HirId { + pub(crate) fn mir_hir_id(&self) -> hir::HirId { self.infcx.tcx.hir().local_def_id_to_hir_id(self.mir_def_id()) } @@ -222,7 +222,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { /// ``` /// /// and then return the name `'1` for us to use. - crate fn give_region_a_name(&self, fr: RegionVid) -> Option<RegionName> { + pub(crate) fn give_region_a_name(&self, fr: RegionVid) -> Option<RegionName> { debug!( "give_region_a_name(fr={:?}, counter={:?})", fr, diff --git a/compiler/rustc_borrowck/src/diagnostics/var_name.rs b/compiler/rustc_borrowck/src/diagnostics/var_name.rs index 00f62806753..9ba29f04b1a 100644 --- a/compiler/rustc_borrowck/src/diagnostics/var_name.rs +++ b/compiler/rustc_borrowck/src/diagnostics/var_name.rs @@ -7,7 +7,7 @@ use rustc_span::source_map::Span; use rustc_span::symbol::Symbol; impl<'tcx> RegionInferenceContext<'tcx> { - crate fn get_var_name_and_span_for_region( + pub(crate) fn get_var_name_and_span_for_region( &self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>, @@ -34,7 +34,11 @@ impl<'tcx> RegionInferenceContext<'tcx> { } /// Search the upvars (if any) to find one that references fr. Return its index. - crate fn get_upvar_index_for_region(&self, tcx: TyCtxt<'tcx>, fr: RegionVid) -> Option<usize> { + pub(crate) fn get_upvar_index_for_region( + &self, + tcx: TyCtxt<'tcx>, + fr: RegionVid, + ) -> Option<usize> { let upvar_index = self.universal_regions().defining_ty.upvar_tys().position(|upvar_ty| { debug!("get_upvar_index_for_region: upvar_ty={:?}", upvar_ty); @@ -57,7 +61,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// Given the index of an upvar, finds its name and the span from where it was /// declared. - crate fn get_upvar_name_and_span_for_region( + pub(crate) fn get_upvar_name_and_span_for_region( &self, tcx: TyCtxt<'tcx>, upvars: &[Upvar<'tcx>], @@ -81,7 +85,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// /// N.B., in the case of a closure, the index is indexing into the signature as seen by the /// user - in particular, index 0 is not the implicit self parameter. - crate fn get_argument_index_for_region( + pub(crate) fn get_argument_index_for_region( &self, tcx: TyCtxt<'tcx>, fr: RegionVid, @@ -107,7 +111,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// Given the index of an argument, finds its name (if any) and the span from where it was /// declared. - crate fn get_argument_name_and_span_for_region( + pub(crate) fn get_argument_name_and_span_for_region( &self, body: &Body<'tcx>, local_names: &IndexVec<Local, Option<Symbol>>, diff --git a/compiler/rustc_borrowck/src/facts.rs b/compiler/rustc_borrowck/src/facts.rs index 86b719bdfa0..7f0a637c9d3 100644 --- a/compiler/rustc_borrowck/src/facts.rs +++ b/compiler/rustc_borrowck/src/facts.rs @@ -25,7 +25,7 @@ impl polonius_engine::FactTypes for RustcFacts { pub type AllFacts = PoloniusFacts<RustcFacts>; -crate trait AllFactsExt { +pub(crate) trait AllFactsExt { /// Returns `true` if there is a need to gather `AllFacts` given the /// current `-Z` flags. fn enabled(tcx: TyCtxt<'_>) -> bool; diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 4661805bb1c..a3e7c953ee3 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -2,7 +2,6 @@ #![allow(rustc::potential_query_instability)] #![feature(box_patterns)] -#![feature(crate_visibility_modifier)] #![feature(let_chains)] #![feature(let_else)] #![feature(min_specialization)] diff --git a/compiler/rustc_borrowck/src/location.rs b/compiler/rustc_borrowck/src/location.rs index c89da5514fd..70a31169498 100644 --- a/compiler/rustc_borrowck/src/location.rs +++ b/compiler/rustc_borrowck/src/location.rs @@ -30,7 +30,7 @@ pub enum RichLocation { } impl LocationTable { - crate fn new(body: &Body<'_>) -> Self { + pub(crate) fn new(body: &Body<'_>) -> Self { let mut num_points = 0; let statements_before_block = body .basic_blocks() diff --git a/compiler/rustc_borrowck/src/member_constraints.rs b/compiler/rustc_borrowck/src/member_constraints.rs index f920d9d5c3f..61838c41e39 100644 --- a/compiler/rustc_borrowck/src/member_constraints.rs +++ b/compiler/rustc_borrowck/src/member_constraints.rs @@ -8,7 +8,7 @@ use std::ops::Index; /// Compactly stores a set of `R0 member of [R1...Rn]` constraints, /// indexed by the region `R0`. -crate struct MemberConstraintSet<'tcx, R> +pub(crate) struct MemberConstraintSet<'tcx, R> where R: Copy + Eq, { @@ -28,17 +28,17 @@ where } /// Represents a `R0 member of [R1..Rn]` constraint -crate struct NllMemberConstraint<'tcx> { +pub(crate) struct NllMemberConstraint<'tcx> { next_constraint: Option<NllMemberConstraintIndex>, /// The span where the hidden type was instantiated. - crate definition_span: Span, + pub(crate) definition_span: Span, /// The hidden type in which `R0` appears. (Used in error reporting.) - crate hidden_ty: Ty<'tcx>, + pub(crate) hidden_ty: Ty<'tcx>, /// The region `R0`. - crate member_region_vid: ty::RegionVid, + pub(crate) member_region_vid: ty::RegionVid, /// Index of `R1` in `choice_regions` vector from `MemberConstraintSet`. start_index: usize, @@ -48,7 +48,7 @@ crate struct NllMemberConstraint<'tcx> { } rustc_index::newtype_index! { - crate struct NllMemberConstraintIndex { + pub(crate) struct NllMemberConstraintIndex { DEBUG_FORMAT = "MemberConstraintIndex({})" } } @@ -73,7 +73,7 @@ impl<'tcx> MemberConstraintSet<'tcx, ty::RegionVid> { /// within into `RegionVid` format -- it typically consults the /// `UniversalRegions` data structure that is known to the caller /// (but which this code is unaware of). - crate fn push_constraint( + pub(crate) fn push_constraint( &mut self, m_c: &MemberConstraint<'tcx>, mut to_region_vid: impl FnMut(ty::Region<'tcx>) -> ty::RegionVid, @@ -106,7 +106,7 @@ where /// the original `RegionVid` to an scc index. In some cases, we /// may have multiple `R1` values mapping to the same `R2` key -- that /// is ok, the two sets will be merged. - crate fn into_mapped<R2>( + pub(crate) fn into_mapped<R2>( self, mut map_fn: impl FnMut(R1) -> R2, ) -> MemberConstraintSet<'tcx, R2> @@ -144,14 +144,14 @@ impl<R> MemberConstraintSet<'_, R> where R: Copy + Hash + Eq, { - crate fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ { + pub(crate) fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ { self.constraints.indices() } /// Iterate down the constraint indices associated with a given /// peek-region. You can then use `choice_regions` and other /// methods to access data. - crate fn indices( + pub(crate) fn indices( &self, member_region_vid: R, ) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ { @@ -172,7 +172,7 @@ where /// ```text /// R0 member of [R1..Rn] /// ``` - crate fn choice_regions(&self, pci: NllMemberConstraintIndex) -> &[ty::RegionVid] { + pub(crate) fn choice_regions(&self, pci: NllMemberConstraintIndex) -> &[ty::RegionVid] { let NllMemberConstraint { start_index, end_index, .. } = &self.constraints[pci]; &self.choice_regions[*start_index..*end_index] } diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs index 6f8fae2de29..2440ae9780d 100644 --- a/compiler/rustc_borrowck/src/nll.rs +++ b/compiler/rustc_borrowck/src/nll.rs @@ -42,7 +42,7 @@ pub type PoloniusOutput = Output<RustcFacts>; /// The output of `nll::compute_regions`. This includes the computed `RegionInferenceContext`, any /// closure requirements to propagate, and any generated errors. -crate struct NllOutput<'tcx> { +pub(crate) struct NllOutput<'tcx> { pub regioncx: RegionInferenceContext<'tcx>, pub opaque_type_values: VecMap<DefId, OpaqueHiddenType<'tcx>>, pub polonius_input: Option<Box<AllFacts>>, @@ -457,6 +457,6 @@ impl ToRegionVid for RegionVid { } } -crate trait ConstraintDescription { +pub(crate) trait ConstraintDescription { fn description(&self) -> &'static str; } diff --git a/compiler/rustc_borrowck/src/place_ext.rs b/compiler/rustc_borrowck/src/place_ext.rs index 83ff1595b0b..93d202e49a1 100644 --- a/compiler/rustc_borrowck/src/place_ext.rs +++ b/compiler/rustc_borrowck/src/place_ext.rs @@ -5,7 +5,7 @@ use rustc_middle::mir::{Body, Mutability, Place}; use rustc_middle::ty::{self, TyCtxt}; /// Extension methods for the `Place` type. -crate trait PlaceExt<'tcx> { +pub(crate) trait PlaceExt<'tcx> { /// Returns `true` if we can safely ignore borrows of this place. /// This is true whenever there is no action that the user can do /// to the place `self` that would invalidate the borrow. This is true diff --git a/compiler/rustc_borrowck/src/places_conflict.rs b/compiler/rustc_borrowck/src/places_conflict.rs index 5a935c3b8fb..97335fd0dff 100644 --- a/compiler/rustc_borrowck/src/places_conflict.rs +++ b/compiler/rustc_borrowck/src/places_conflict.rs @@ -14,7 +14,7 @@ use std::iter; /// being run in the calling context, the conservative choice is to assume the compared indices /// are disjoint (and therefore, do not overlap). #[derive(Copy, Clone, Debug, Eq, PartialEq)] -crate enum PlaceConflictBias { +pub(crate) enum PlaceConflictBias { Overlap, NoOverlap, } @@ -22,7 +22,7 @@ crate enum PlaceConflictBias { /// Helper function for checking if places conflict with a mutable borrow and deep access depth. /// This is used to check for places conflicting outside of the borrow checking code (such as in /// dataflow). -crate fn places_conflict<'tcx>( +pub(crate) fn places_conflict<'tcx>( tcx: TyCtxt<'tcx>, body: &Body<'tcx>, borrow_place: Place<'tcx>, diff --git a/compiler/rustc_borrowck/src/region_infer/graphviz.rs b/compiler/rustc_borrowck/src/region_infer/graphviz.rs index 95048d50f11..f31ccd74ca6 100644 --- a/compiler/rustc_borrowck/src/region_infer/graphviz.rs +++ b/compiler/rustc_borrowck/src/region_infer/graphviz.rs @@ -11,12 +11,12 @@ use rustc_graphviz as dot; impl<'tcx> RegionInferenceContext<'tcx> { /// Write out the region constraint graph. - crate fn dump_graphviz_raw_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> { + pub(crate) fn dump_graphviz_raw_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> { dot::render(&RawConstraints { regioncx: self }, &mut w) } /// Write out the region constraint graph. - crate fn dump_graphviz_scc_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> { + pub(crate) fn dump_graphviz_scc_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> { let mut nodes_per_scc: IndexVec<ConstraintSccIndex, _> = self.constraint_sccs.all_sccs().map(|_| Vec::new()).collect(); diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs index b2fa16ce125..dc6337c54ed 100644 --- a/compiler/rustc_borrowck/src/region_infer/mod.rs +++ b/compiler/rustc_borrowck/src/region_infer/mod.rs @@ -513,26 +513,26 @@ impl<'tcx> RegionInferenceContext<'tcx> { } /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`. - crate fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) { + pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) { self.universal_regions.annotate(tcx, err) } /// Returns `true` if the region `r` contains the point `p`. /// /// Panics if called before `solve()` executes, - crate fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool { + pub(crate) fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool { let scc = self.constraint_sccs.scc(r.to_region_vid()); self.scc_values.contains(scc, p) } /// Returns access to the value of `r` for debugging purposes. - crate fn region_value_str(&self, r: RegionVid) -> String { + pub(crate) fn region_value_str(&self, r: RegionVid) -> String { let scc = self.constraint_sccs.scc(r.to_region_vid()); self.scc_values.region_value_str(scc) } /// Returns access to the value of `r` for debugging purposes. - crate fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex { + pub(crate) fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex { let scc = self.constraint_sccs.scc(r.to_region_vid()); self.scc_universes[scc] } @@ -1693,7 +1693,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// that cannot be named by `fr1`; in that case, we will require /// that `fr1: 'static` because it is the only way to `fr1: r` to /// be satisfied. (See `add_incompatible_universe`.) - crate fn provides_universal_region( + pub(crate) fn provides_universal_region( &self, r: RegionVid, fr1: RegionVid, @@ -1712,7 +1712,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// If `r2` represents a placeholder region, then this returns /// `true` if `r1` cannot name that placeholder in its /// value; otherwise, returns `false`. - crate fn cannot_name_placeholder(&self, r1: RegionVid, r2: RegionVid) -> bool { + pub(crate) fn cannot_name_placeholder(&self, r1: RegionVid, r2: RegionVid) -> bool { debug!("cannot_name_value_of(r1={:?}, r2={:?})", r1, r2); match self.definitions[r2].origin { @@ -1731,7 +1731,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { } } - crate fn retrieve_closure_constraint_info( + pub(crate) fn retrieve_closure_constraint_info( &self, _body: &Body<'tcx>, constraint: &OutlivesConstraint<'tcx>, @@ -1766,7 +1766,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { } /// Finds a good `ObligationCause` to blame for the fact that `fr1` outlives `fr2`. - crate fn find_outlives_blame_span( + pub(crate) fn find_outlives_blame_span( &self, body: &Body<'tcx>, fr1: RegionVid, @@ -1788,7 +1788,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// /// Returns: a series of constraints as well as the region `R` /// that passed the target test. - crate fn find_constraint_paths_between_regions( + pub(crate) fn find_constraint_paths_between_regions( &self, from_region: RegionVid, target_test: impl Fn(RegionVid) -> bool, @@ -1882,7 +1882,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// Finds some region R such that `fr1: R` and `R` is live at `elem`. #[instrument(skip(self), level = "trace")] - crate fn find_sub_region_live_at(&self, fr1: RegionVid, elem: Location) -> RegionVid { + pub(crate) fn find_sub_region_live_at(&self, fr1: RegionVid, elem: Location) -> RegionVid { trace!(scc = ?self.constraint_sccs.scc(fr1)); trace!(universe = ?self.scc_universes[self.constraint_sccs.scc(fr1)]); self.find_constraint_paths_between_regions(fr1, |r| { @@ -1919,7 +1919,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { } /// Get the region outlived by `longer_fr` and live at `element`. - crate fn region_from_element( + pub(crate) fn region_from_element( &self, longer_fr: RegionVid, element: &RegionElement, @@ -1939,17 +1939,17 @@ impl<'tcx> RegionInferenceContext<'tcx> { } /// Get the region definition of `r`. - crate fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> { + pub(crate) fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> { &self.definitions[r] } /// Check if the SCC of `r` contains `upper`. - crate fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool { + pub(crate) fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool { let r_scc = self.constraint_sccs.scc(r); self.scc_values.contains(r_scc, upper) } - crate fn universal_regions(&self) -> &UniversalRegions<'tcx> { + pub(crate) fn universal_regions(&self) -> &UniversalRegions<'tcx> { self.universal_regions.as_ref() } @@ -1959,7 +1959,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { /// creating a constraint path that forces `R` to outlive /// `from_region`, and then finding the best choices within that /// path to blame. - crate fn best_blame_constraint( + pub(crate) fn best_blame_constraint( &self, body: &Body<'tcx>, from_region: RegionVid, @@ -2171,7 +2171,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { categorized_path.remove(0) } - crate fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> { + pub(crate) fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> { self.universe_causes[&universe].clone() } } diff --git a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs index 056907dcb16..1e6798eee3d 100644 --- a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs +++ b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs @@ -8,7 +8,7 @@ use rustc_middle::ty::RegionVid; use std::ops::Range; use std::rc::Rc; -crate struct ReverseSccGraph { +pub(crate) struct ReverseSccGraph { graph: VecGraph<ConstraintSccIndex>, /// For each SCC, the range of `universal_regions` that use that SCC as /// their value. diff --git a/compiler/rustc_borrowck/src/region_infer/values.rs b/compiler/rustc_borrowck/src/region_infer/values.rs index 4a70535c63b..c81ef10f7c7 100644 --- a/compiler/rustc_borrowck/src/region_infer/values.rs +++ b/compiler/rustc_borrowck/src/region_infer/values.rs @@ -10,7 +10,7 @@ use std::fmt::Debug; use std::rc::Rc; /// Maps between a `Location` and a `PointIndex` (and vice versa). -crate struct RegionValueElements { +pub(crate) struct RegionValueElements { /// For each basic block, how many points are contained within? statements_before_block: IndexVec<BasicBlock, usize>, @@ -22,7 +22,7 @@ crate struct RegionValueElements { } impl RegionValueElements { - crate fn new(body: &Body<'_>) -> Self { + pub(crate) fn new(body: &Body<'_>) -> Self { let mut num_points = 0; let statements_before_block: IndexVec<BasicBlock, usize> = body .basic_blocks() @@ -45,30 +45,30 @@ impl RegionValueElements { } /// Total number of point indices - crate fn num_points(&self) -> usize { + pub(crate) fn num_points(&self) -> usize { self.num_points } /// Converts a `Location` into a `PointIndex`. O(1). - crate fn point_from_location(&self, location: Location) -> PointIndex { + pub(crate) fn point_from_location(&self, location: Location) -> PointIndex { let Location { block, statement_index } = location; let start_index = self.statements_before_block[block]; PointIndex::new(start_index + statement_index) } /// Converts a `Location` into a `PointIndex`. O(1). - crate fn entry_point(&self, block: BasicBlock) -> PointIndex { + pub(crate) fn entry_point(&self, block: BasicBlock) -> PointIndex { let start_index = self.statements_before_block[block]; PointIndex::new(start_index) } /// Return the PointIndex for the block start of this index. - crate fn to_block_start(&self, index: PointIndex) -> PointIndex { + pub(crate) fn to_block_start(&self, index: PointIndex) -> PointIndex { PointIndex::new(self.statements_before_block[self.basic_blocks[index]]) } /// Converts a `PointIndex` back to a location. O(1). - crate fn to_location(&self, index: PointIndex) -> Location { + pub(crate) fn to_location(&self, index: PointIndex) -> Location { assert!(index.index() < self.num_points); let block = self.basic_blocks[index]; let start_index = self.statements_before_block[block]; @@ -80,7 +80,7 @@ impl RegionValueElements { /// out of range (because they round up to the nearest 2^N number /// of bits). Use this function to filter such points out if you /// like. - crate fn point_in_range(&self, index: PointIndex) -> bool { + pub(crate) fn point_in_range(&self, index: PointIndex) -> bool { index.index() < self.num_points } } @@ -99,7 +99,7 @@ rustc_index::newtype_index! { /// An individual element in a region value -- the value of a /// particular region variable consists of a set of these elements. #[derive(Debug, Clone)] -crate enum RegionElement { +pub(crate) enum RegionElement { /// A point in the control-flow graph. Location(Location), @@ -114,7 +114,7 @@ crate enum RegionElement { /// When we initially compute liveness, we use an interval matrix storing /// liveness ranges for each region-vid. -crate struct LivenessValues<N: Idx> { +pub(crate) struct LivenessValues<N: Idx> { elements: Rc<RegionValueElements>, points: SparseIntervalMatrix<N, PointIndex>, } @@ -123,18 +123,18 @@ impl<N: Idx> LivenessValues<N> { /// Creates a new set of "region values" that tracks causal information. /// Each of the regions in num_region_variables will be initialized with an /// empty set of points and no causal information. - crate fn new(elements: Rc<RegionValueElements>) -> Self { + pub(crate) fn new(elements: Rc<RegionValueElements>) -> Self { Self { points: SparseIntervalMatrix::new(elements.num_points), elements } } /// Iterate through each region that has a value in this set. - crate fn rows(&self) -> impl Iterator<Item = N> { + pub(crate) fn rows(&self) -> impl Iterator<Item = N> { self.points.rows() } /// Adds the given element to the value for the given region. Returns whether /// the element is newly added (i.e., was not already present). - crate fn add_element(&mut self, row: N, location: Location) -> bool { + pub(crate) fn add_element(&mut self, row: N, location: Location) -> bool { debug!("LivenessValues::add(r={:?}, location={:?})", row, location); let index = self.elements.point_from_location(location); self.points.insert(row, index) @@ -142,24 +142,24 @@ impl<N: Idx> LivenessValues<N> { /// Adds all the elements in the given bit array into the given /// region. Returns whether any of them are newly added. - crate fn add_elements(&mut self, row: N, locations: &IntervalSet<PointIndex>) -> bool { + pub(crate) fn add_elements(&mut self, row: N, locations: &IntervalSet<PointIndex>) -> bool { debug!("LivenessValues::add_elements(row={:?}, locations={:?})", row, locations); self.points.union_row(row, locations) } /// Adds all the control-flow points to the values for `r`. - crate fn add_all_points(&mut self, row: N) { + pub(crate) fn add_all_points(&mut self, row: N) { self.points.insert_all_into_row(row); } /// Returns `true` if the region `r` contains the given element. - crate fn contains(&self, row: N, location: Location) -> bool { + pub(crate) fn contains(&self, row: N, location: Location) -> bool { let index = self.elements.point_from_location(location); self.points.row(row).map_or(false, |r| r.contains(index)) } /// Returns an iterator of all the elements contained by the region `r` - crate fn get_elements(&self, row: N) -> impl Iterator<Item = Location> + '_ { + pub(crate) fn get_elements(&self, row: N) -> impl Iterator<Item = Location> + '_ { self.points .row(row) .into_iter() @@ -169,7 +169,7 @@ impl<N: Idx> LivenessValues<N> { } /// Returns a "pretty" string value of the region. Meant for debugging. - crate fn region_value_str(&self, r: N) -> String { + pub(crate) fn region_value_str(&self, r: N) -> String { region_value_str(self.get_elements(r).map(RegionElement::Location)) } } @@ -178,25 +178,28 @@ impl<N: Idx> LivenessValues<N> { /// rustc to the internal `PlaceholderIndex` values that are used in /// NLL. #[derive(Default)] -crate struct PlaceholderIndices { +pub(crate) struct PlaceholderIndices { indices: FxIndexSet<ty::PlaceholderRegion>, } impl PlaceholderIndices { - crate fn insert(&mut self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex { + pub(crate) fn insert(&mut self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex { let (index, _) = self.indices.insert_full(placeholder); index.into() } - crate fn lookup_index(&self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex { + pub(crate) fn lookup_index(&self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex { self.indices.get_index_of(&placeholder).unwrap().into() } - crate fn lookup_placeholder(&self, placeholder: PlaceholderIndex) -> ty::PlaceholderRegion { + pub(crate) fn lookup_placeholder( + &self, + placeholder: PlaceholderIndex, + ) -> ty::PlaceholderRegion { self.indices[placeholder.index()] } - crate fn len(&self) -> usize { + pub(crate) fn len(&self) -> usize { self.indices.len() } } @@ -220,7 +223,7 @@ impl PlaceholderIndices { /// because (since it is returned) it must live for at least `'a`. But /// it would also contain various points from within the function. #[derive(Clone)] -crate struct RegionValues<N: Idx> { +pub(crate) struct RegionValues<N: Idx> { elements: Rc<RegionValueElements>, placeholder_indices: Rc<PlaceholderIndices>, points: SparseIntervalMatrix<N, PointIndex>, @@ -235,7 +238,7 @@ impl<N: Idx> RegionValues<N> { /// Creates a new set of "region values" that tracks causal information. /// Each of the regions in num_region_variables will be initialized with an /// empty set of points and no causal information. - crate fn new( + pub(crate) fn new( elements: &Rc<RegionValueElements>, num_universal_regions: usize, placeholder_indices: &Rc<PlaceholderIndices>, @@ -252,33 +255,33 @@ impl<N: Idx> RegionValues<N> { /// Adds the given element to the value for the given region. Returns whether /// the element is newly added (i.e., was not already present). - crate fn add_element(&mut self, r: N, elem: impl ToElementIndex) -> bool { + pub(crate) fn add_element(&mut self, r: N, elem: impl ToElementIndex) -> bool { debug!("add(r={:?}, elem={:?})", r, elem); elem.add_to_row(self, r) } /// Adds all the control-flow points to the values for `r`. - crate fn add_all_points(&mut self, r: N) { + pub(crate) fn add_all_points(&mut self, r: N) { self.points.insert_all_into_row(r); } /// Adds all elements in `r_from` to `r_to` (because e.g., `r_to: /// r_from`). - crate fn add_region(&mut self, r_to: N, r_from: N) -> bool { + pub(crate) fn add_region(&mut self, r_to: N, r_from: N) -> bool { self.points.union_rows(r_from, r_to) | self.free_regions.union_rows(r_from, r_to) | self.placeholders.union_rows(r_from, r_to) } /// Returns `true` if the region `r` contains the given element. - crate fn contains(&self, r: N, elem: impl ToElementIndex) -> bool { + pub(crate) fn contains(&self, r: N, elem: impl ToElementIndex) -> bool { elem.contained_in_row(self, r) } /// `self[to] |= values[from]`, essentially: that is, take all the /// elements for the region `from` from `values` and add them to /// the region `to` in `self`. - crate fn merge_liveness<M: Idx>(&mut self, to: N, from: M, values: &LivenessValues<M>) { + pub(crate) fn merge_liveness<M: Idx>(&mut self, to: N, from: M, values: &LivenessValues<M>) { if let Some(set) = values.points.row(from) { self.points.union_row(to, set); } @@ -286,7 +289,7 @@ impl<N: Idx> RegionValues<N> { /// Returns `true` if `sup_region` contains all the CFG points that /// `sub_region` contains. Ignores universal regions. - crate fn contains_points(&self, sup_region: N, sub_region: N) -> bool { + pub(crate) fn contains_points(&self, sup_region: N, sub_region: N) -> bool { if let Some(sub_row) = self.points.row(sub_region) { if let Some(sup_row) = self.points.row(sup_region) { sup_row.superset(sub_row) @@ -301,7 +304,7 @@ impl<N: Idx> RegionValues<N> { } /// Returns the locations contained within a given region `r`. - crate fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a { + pub(crate) fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a { self.points.row(r).into_iter().flat_map(move |set| { set.iter() .take_while(move |&p| self.elements.point_in_range(p)) @@ -310,7 +313,7 @@ impl<N: Idx> RegionValues<N> { } /// Returns just the universal regions that are contained in a given region's value. - crate fn universal_regions_outlived_by<'a>( + pub(crate) fn universal_regions_outlived_by<'a>( &'a self, r: N, ) -> impl Iterator<Item = RegionVid> + 'a { @@ -318,7 +321,7 @@ impl<N: Idx> RegionValues<N> { } /// Returns all the elements contained in a given region's value. - crate fn placeholders_contained_in<'a>( + pub(crate) fn placeholders_contained_in<'a>( &'a self, r: N, ) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a { @@ -330,7 +333,10 @@ impl<N: Idx> RegionValues<N> { } /// Returns all the elements contained in a given region's value. - crate fn elements_contained_in<'a>(&'a self, r: N) -> impl Iterator<Item = RegionElement> + 'a { + pub(crate) fn elements_contained_in<'a>( + &'a self, + r: N, + ) -> impl Iterator<Item = RegionElement> + 'a { let points_iter = self.locations_outlived_by(r).map(RegionElement::Location); let free_regions_iter = @@ -343,12 +349,12 @@ impl<N: Idx> RegionValues<N> { } /// Returns a "pretty" string value of the region. Meant for debugging. - crate fn region_value_str(&self, r: N) -> String { + pub(crate) fn region_value_str(&self, r: N) -> String { region_value_str(self.elements_contained_in(r)) } } -crate trait ToElementIndex: Debug + Copy { +pub(crate) trait ToElementIndex: Debug + Copy { fn add_to_row<N: Idx>(self, values: &mut RegionValues<N>, row: N) -> bool; fn contained_in_row<N: Idx>(self, values: &RegionValues<N>, row: N) -> bool; @@ -388,7 +394,7 @@ impl ToElementIndex for ty::PlaceholderRegion { } } -crate fn location_set_str( +pub(crate) fn location_set_str( elements: &RegionValueElements, points: impl IntoIterator<Item = PointIndex>, ) -> String { diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs index 21190a850b7..f11a94d7ddd 100644 --- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs +++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs @@ -18,7 +18,7 @@ use crate::{ universal_regions::UniversalRegions, }; -crate struct ConstraintConversion<'a, 'tcx> { +pub(crate) struct ConstraintConversion<'a, 'tcx> { infcx: &'a InferCtxt<'a, 'tcx>, tcx: TyCtxt<'tcx>, universal_regions: &'a UniversalRegions<'tcx>, @@ -32,7 +32,7 @@ crate struct ConstraintConversion<'a, 'tcx> { } impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> { - crate fn new( + pub(crate) fn new( infcx: &'a InferCtxt<'a, 'tcx>, universal_regions: &'a UniversalRegions<'tcx>, region_bound_pairs: &'a RegionBoundPairs<'tcx>, diff --git a/compiler/rustc_borrowck/src/type_check/free_region_relations.rs b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs index f08f2e1b12d..670b5549afc 100644 --- a/compiler/rustc_borrowck/src/type_check/free_region_relations.rs +++ b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs @@ -19,7 +19,7 @@ use crate::{ }; #[derive(Debug)] -crate struct UniversalRegionRelations<'tcx> { +pub(crate) struct UniversalRegionRelations<'tcx> { universal_regions: Rc<UniversalRegions<'tcx>>, /// Stores the outlives relations that are known to hold from the @@ -52,13 +52,13 @@ type RegionBoundPairs<'tcx> = Vec<(ty::Region<'tcx>, GenericKind<'tcx>)>; /// then the output type as the last element. type NormalizedInputsAndOutput<'tcx> = Vec<Ty<'tcx>>; -crate struct CreateResult<'tcx> { - crate universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>, - crate region_bound_pairs: RegionBoundPairs<'tcx>, - crate normalized_inputs_and_output: NormalizedInputsAndOutput<'tcx>, +pub(crate) struct CreateResult<'tcx> { + pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>, + pub(crate) region_bound_pairs: RegionBoundPairs<'tcx>, + pub(crate) normalized_inputs_and_output: NormalizedInputsAndOutput<'tcx>, } -crate fn create<'tcx>( +pub(crate) fn create<'tcx>( infcx: &InferCtxt<'_, 'tcx>, param_env: ty::ParamEnv<'tcx>, implicit_region_bound: Option<ty::Region<'tcx>>, @@ -96,7 +96,7 @@ impl UniversalRegionRelations<'_> { /// /// (See `TransitiveRelation::postdom_upper_bound` for details on /// the postdominating upper bound in general.) - crate fn postdom_upper_bound(&self, fr1: RegionVid, fr2: RegionVid) -> RegionVid { + pub(crate) fn postdom_upper_bound(&self, fr1: RegionVid, fr2: RegionVid) -> RegionVid { assert!(self.universal_regions.is_universal_region(fr1)); assert!(self.universal_regions.is_universal_region(fr2)); self.inverse_outlives @@ -109,7 +109,7 @@ impl UniversalRegionRelations<'_> { /// outlives `fr` and (b) is not local. /// /// (*) If there are multiple competing choices, we return all of them. - crate fn non_local_upper_bounds<'a>(&'a self, fr: RegionVid) -> Vec<RegionVid> { + pub(crate) fn non_local_upper_bounds<'a>(&'a self, fr: RegionVid) -> Vec<RegionVid> { debug!("non_local_upper_bound(fr={:?})", fr); let res = self.non_local_bounds(&self.inverse_outlives, fr); assert!(!res.is_empty(), "can't find an upper bound!?"); @@ -118,7 +118,7 @@ impl UniversalRegionRelations<'_> { /// Returns the "postdominating" bound of the set of /// `non_local_upper_bounds` for the given region. - crate fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid { + pub(crate) fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid { let upper_bounds = self.non_local_upper_bounds(fr); // In case we find more than one, reduce to one for @@ -147,7 +147,7 @@ impl UniversalRegionRelations<'_> { /// /// (*) If there are multiple competing choices, we pick the "postdominating" /// one. See `TransitiveRelation::postdom_upper_bound` for details. - crate fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> { + pub(crate) fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> { debug!("non_local_lower_bound(fr={:?})", fr); let lower_bounds = self.non_local_bounds(&self.outlives, fr); @@ -203,18 +203,18 @@ impl UniversalRegionRelations<'_> { /// Returns `true` if fr1 is known to outlive fr2. /// /// This will only ever be true for universally quantified regions. - crate fn outlives(&self, fr1: RegionVid, fr2: RegionVid) -> bool { + pub(crate) fn outlives(&self, fr1: RegionVid, fr2: RegionVid) -> bool { self.outlives.contains(fr1, fr2) } /// Returns a vector of free regions `x` such that `fr1: x` is /// known to hold. - crate fn regions_outlived_by(&self, fr1: RegionVid) -> Vec<RegionVid> { + pub(crate) fn regions_outlived_by(&self, fr1: RegionVid) -> Vec<RegionVid> { self.outlives.reachable_from(fr1) } /// Returns the _non-transitive_ set of known `outlives` constraints between free regions. - crate fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> + '_ { + pub(crate) fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> + '_ { self.outlives.base_edges() } } @@ -232,7 +232,7 @@ struct UniversalRegionRelationsBuilder<'this, 'tcx> { } impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> { - crate fn create(mut self) -> CreateResult<'tcx> { + pub(crate) fn create(mut self) -> CreateResult<'tcx> { let unnormalized_input_output_tys = self .universal_regions .unnormalized_input_tys diff --git a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs index dd23683fae8..b88f6e689cc 100644 --- a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs +++ b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs @@ -18,7 +18,7 @@ use crate::region_infer::values::{PointIndex, RegionValueElements}; /// (and code simplicity) was favored. The rationale is that we only keep /// a small number of `IndexVec`s throughout the entire analysis while, in /// contrast, we're accessing each `Local` *many* times. -crate struct LocalUseMap { +pub(crate) struct LocalUseMap { /// Head of a linked list of **definitions** of each variable -- /// definition in this context means assignment, e.g., `x` is /// defined in `x = y` but not `y`; that first def is the head of @@ -58,7 +58,11 @@ impl vll::LinkElem for Appearance { } impl LocalUseMap { - crate fn build(live_locals: &[Local], elements: &RegionValueElements, body: &Body<'_>) -> Self { + pub(crate) fn build( + live_locals: &[Local], + elements: &RegionValueElements, + body: &Body<'_>, + ) -> Self { let nones = IndexVec::from_elem_n(None, body.local_decls.len()); let mut local_use_map = LocalUseMap { first_def_at: nones.clone(), @@ -81,17 +85,17 @@ impl LocalUseMap { local_use_map } - crate fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { + pub(crate) fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { vll::iter(self.first_def_at[local], &self.appearances) .map(move |aa| self.appearances[aa].point_index) } - crate fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { + pub(crate) fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { vll::iter(self.first_use_at[local], &self.appearances) .map(move |aa| self.appearances[aa].point_index) } - crate fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { + pub(crate) fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ { vll::iter(self.first_drop_at[local], &self.appearances) .map(move |aa| self.appearances[aa].point_index) } diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs index 4b905c23e15..405fd9198d3 100644 --- a/compiler/rustc_borrowck/src/type_check/mod.rs +++ b/compiler/rustc_borrowck/src/type_check/mod.rs @@ -94,7 +94,7 @@ mod canonical; mod constraint_conversion; pub mod free_region_relations; mod input_output; -crate mod liveness; +pub(crate) mod liveness; mod relate_tys; /// Type checks the given `mir` in the context of the inference @@ -897,28 +897,29 @@ struct BorrowCheckContext<'a, 'tcx> { upvars: &'a [Upvar<'tcx>], } -crate struct MirTypeckResults<'tcx> { - crate constraints: MirTypeckRegionConstraints<'tcx>, - crate universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>, - crate opaque_type_values: VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>, +pub(crate) struct MirTypeckResults<'tcx> { + pub(crate) constraints: MirTypeckRegionConstraints<'tcx>, + pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>, + pub(crate) opaque_type_values: + VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>, } /// A collection of region constraints that must be satisfied for the /// program to be considered well-typed. -crate struct MirTypeckRegionConstraints<'tcx> { +pub(crate) struct MirTypeckRegionConstraints<'tcx> { /// Maps from a `ty::Placeholder` to the corresponding /// `PlaceholderIndex` bit that we will use for it. /// /// To keep everything in sync, do not insert this set /// directly. Instead, use the `placeholder_region` helper. - crate placeholder_indices: PlaceholderIndices, + pub(crate) placeholder_indices: PlaceholderIndices, /// Each time we add a placeholder to `placeholder_indices`, we /// also create a corresponding "representative" region vid for /// that wraps it. This vector tracks those. This way, when we /// convert the same `ty::RePlaceholder(p)` twice, we can map to /// the same underlying `RegionVid`. - crate placeholder_index_to_region: IndexVec<PlaceholderIndex, ty::Region<'tcx>>, + pub(crate) placeholder_index_to_region: IndexVec<PlaceholderIndex, ty::Region<'tcx>>, /// In general, the type-checker is not responsible for enforcing /// liveness constraints; this job falls to the region inferencer, @@ -927,18 +928,18 @@ crate struct MirTypeckRegionConstraints<'tcx> { /// not otherwise appear in the MIR -- in particular, the /// late-bound regions that it instantiates at call-sites -- and /// hence it must report on their liveness constraints. - crate liveness_constraints: LivenessValues<RegionVid>, + pub(crate) liveness_constraints: LivenessValues<RegionVid>, - crate outlives_constraints: OutlivesConstraintSet<'tcx>, + pub(crate) outlives_constraints: OutlivesConstraintSet<'tcx>, - crate member_constraints: MemberConstraintSet<'tcx, RegionVid>, + pub(crate) member_constraints: MemberConstraintSet<'tcx, RegionVid>, - crate closure_bounds_mapping: + pub(crate) closure_bounds_mapping: FxHashMap<Location, FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>>, - crate universe_causes: FxHashMap<ty::UniverseIndex, UniverseInfo<'tcx>>, + pub(crate) universe_causes: FxHashMap<ty::UniverseIndex, UniverseInfo<'tcx>>, - crate type_tests: Vec<TypeTest<'tcx>>, + pub(crate) type_tests: Vec<TypeTest<'tcx>>, } impl<'tcx> MirTypeckRegionConstraints<'tcx> { diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs index 0fcac9a1c6c..7b63ec516b8 100644 --- a/compiler/rustc_borrowck/src/universal_regions.rs +++ b/compiler/rustc_borrowck/src/universal_regions.rs @@ -336,7 +336,7 @@ impl<'tcx> UniversalRegions<'tcx> { /// that this region imposes on others. The methods in this file /// handle the part about dumping the inference context internal /// state. - crate fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) { + pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) { match self.defining_ty { DefiningTy::Closure(def_id, substs) => { err.note(&format!( diff --git a/compiler/rustc_borrowck/src/used_muts.rs b/compiler/rustc_borrowck/src/used_muts.rs index 6022a980950..cdbb60b878a 100644 --- a/compiler/rustc_borrowck/src/used_muts.rs +++ b/compiler/rustc_borrowck/src/used_muts.rs @@ -22,7 +22,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { /// been assigned to - this set is used as a proxy for locals that were not initialized due to /// unreachable code. These locals are then considered "used" to silence the lint for them. /// See #55344 for context. - crate fn gather_used_muts( + pub(crate) fn gather_used_muts( &mut self, temporary_used_locals: FxHashSet<Local>, mut never_initialized_mut_locals: FxHashSet<Local>, |