Remove references from some structs.

In all cases the struct can own the relevant thing instead of having a
reference to it. This makes the code simpler, and in some cases removes
a struct lifetime.

Author: nnethercote

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -242,7 +242,7 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 }
  round_count += 1;
 
-apply_merges(body, tcx,&merges,&merged_locals);
+apply_merges(body, tcx, merges, merged_locals);
 }
 
 trace!(round_count);
@@ -281,20 +281,20 @@ struct Candidates {
 fnapply_merges<'tcx>(
 body:&mutBody<'tcx>,
 tcx:TyCtxt<'tcx>,
-merges:&FxIndexMap<Local,Local>,
-merged_locals:&BitSet<Local>,
+merges:FxIndexMap<Local,Local>,
+merged_locals:BitSet<Local>,
 ){
 letmut merger = Merger{ tcx, merges, merged_locals };
  merger.visit_body_preserves_cfg(body);
 }
 
-structMerger<'a,'tcx>{
+structMerger<'tcx>{
 tcx:TyCtxt<'tcx>,
-merges:&'aFxIndexMap<Local,Local>,
-merged_locals:&'aBitSet<Local>,
+merges:FxIndexMap<Local,Local>,
+merged_locals:BitSet<Local>,
 }
 
-impl<'a,'tcx>MutVisitor<'tcx>forMerger<'a,'tcx>{
+impl<'tcx>MutVisitor<'tcx>forMerger<'tcx>{
 fntcx(&self) -> TyCtxt<'tcx>{
 self.tcx
 }

compiler/rustc_mir_transform/src/gvn.rs

@@ -125,7 +125,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
 // Clone dominators because we need them while mutating the body.
 let dominators = body.basic_blocks.dominators().clone();
 
-letmut state = VnState::new(tcx, body, param_env,&ssa,&dominators,&body.local_decls);
+letmut state = VnState::new(tcx, body, param_env,&ssa, dominators,&body.local_decls);
  ssa.for_each_assignment_mut(
  body.basic_blocks.as_mut_preserves_cfg(),
  |local, value, location| {
@@ -258,7 +258,7 @@ struct VnState<'body, 'tcx> {
 /// Cache the value of the `unsized_locals` features, to avoid fetching it repeatedly in a loop.
 feature_unsized_locals:bool,
 ssa:&'bodySsaLocals,
-dominators:&'bodyDominators<BasicBlock>,
+dominators:Dominators<BasicBlock>,
 reused_locals:BitSet<Local>,
 }
 
@@ -268,7 +268,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 body:&Body<'tcx>,
 param_env: ty::ParamEnv<'tcx>,
 ssa:&'bodySsaLocals,
-dominators:&'bodyDominators<BasicBlock>,
+dominators:Dominators<BasicBlock>,
 local_decls:&'bodyLocalDecls<'tcx>,
 ) -> Self{
 // Compute a rough estimate of the number of values in the body from the number of
@@ -1490,7 +1490,7 @@ impl<'tcx> VnState<'_, 'tcx> {
 let other = self.rev_locals.get(index)?;
  other
 .iter()
-.find(|&&other| self.ssa.assignment_dominates(self.dominators, other, loc))
+.find(|&&other| self.ssa.assignment_dominates(&self.dominators, other, loc))
 .copied()
 }
 }

compiler/rustc_mir_transform/src/jump_threading.rs

@@ -78,18 +78,16 @@ impl<'tcx> crate::MirPass<'tcx> for JumpThreading {
 }
 
 let param_env = tcx.param_env_reveal_all_normalized(def_id);
-let map = Map::new(tcx, body,Some(MAX_PLACES));
-let loop_headers = loop_headers(body);
 
-let arena = DroplessArena::default();
+let arena = &DroplessArena::default();
 letmut finder = TOFinder{
  tcx,
  param_env,
 ecx:InterpCx::new(tcx,DUMMY_SP, param_env,DummyMachine),
  body,
-arena:&arena,
-map:&map,
-loop_headers:&loop_headers,
+ arena,
+map:Map::new(tcx, body,Some(MAX_PLACES)),
+loop_headers:loop_headers(body),
 opportunities:Vec::new(),
 };
 
@@ -105,7 +103,7 @@ impl<'tcx> crate::MirPass<'tcx> for JumpThreading {
 
 // Verify that we do not thread through a loop header.
 for to in opportunities.iter(){
-assert!(to.chain.iter().all(|&block| !loop_headers.contains(block)));
+assert!(to.chain.iter().all(|&block| !finder.loop_headers.contains(block)));
 }
 OpportunitySet::new(body, opportunities).apply(body);
 }
@@ -124,8 +122,8 @@ struct TOFinder<'tcx, 'a> {
 param_env: ty::ParamEnv<'tcx>,
 ecx:InterpCx<'tcx,DummyMachine>,
 body:&'aBody<'tcx>,
-map:&'aMap<'tcx>,
-loop_headers:&'aBitSet<BasicBlock>,
+map:Map<'tcx>,
+loop_headers:BitSet<BasicBlock>,
 /// We use an arena to avoid cloning the slices when cloning `state`.
 arena:&'aDroplessArena,
 opportunities:Vec<ThreadingOpportunity>,
@@ -223,7 +221,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 }))
 };
 let conds = ConditionSet(conds);
- state.insert_value_idx(discr, conds,self.map);
+ state.insert_value_idx(discr, conds,&self.map);
 
 self.find_opportunity(bb, state, cost,0);
 }
@@ -264,7 +262,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 // _1 = 5 // Whatever happens here, it won't change the result of a `SwitchInt`.
 // _1 = 6
 ifletSome((lhs, tail)) = self.mutated_statement(stmt){
- state.flood_with_tail_elem(lhs.as_ref(), tail,self.map,ConditionSet::BOTTOM);
+ state.flood_with_tail_elem(lhs.as_ref(), tail,&self.map,ConditionSet::BOTTOM);
 }
 }
 
@@ -370,7 +368,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 self.opportunities.push(ThreadingOpportunity{chain:vec![bb],target: c.target})
 };
 
-ifletSome(conditions) = state.try_get_idx(lhs,self.map)
+ifletSome(conditions) = state.try_get_idx(lhs,&self.map)
  && letImmediate::Scalar(Scalar::Int(int)) = *rhs
 {
  conditions.iter_matches(int).for_each(register_opportunity);
@@ -406,7 +404,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 }
 },
 &mut |place, op| {
-ifletSome(conditions) = state.try_get_idx(place,self.map)
+ifletSome(conditions) = state.try_get_idx(place,&self.map)
  && letOk(imm) = self.ecx.read_immediate_raw(op)
  && letSome(imm) = imm.right()
  && letImmediate::Scalar(Scalar::Int(int)) = *imm
@@ -441,7 +439,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 // Transfer the conditions on the copied rhs.
 Operand::Move(rhs) | Operand::Copy(rhs) => {
 letSome(rhs) = self.map.find(rhs.as_ref())else{return};
- state.insert_place_idx(rhs, lhs,self.map);
+ state.insert_place_idx(rhs, lhs,&self.map);
 }
 }
 }
@@ -461,7 +459,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 Rvalue::CopyForDeref(rhs) => self.process_operand(bb, lhs,&Operand::Copy(*rhs), state),
 Rvalue::Discriminant(rhs) => {
 letSome(rhs) = self.map.find_discr(rhs.as_ref())else{return};
- state.insert_place_idx(rhs, lhs,self.map);
+ state.insert_place_idx(rhs, lhs,&self.map);
 }
 // If we expect `lhs ?= A`, we have an opportunity if we assume `constant == A`.
 Rvalue::Aggregate(box ref kind,ref operands) => {
@@ -492,10 +490,10 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 }
 // Transfer the conditions on the copy rhs, after inversing polarity.
 Rvalue::UnaryOp(UnOp::Not,Operand::Move(place) | Operand::Copy(place)) => {
-letSome(conditions) = state.try_get_idx(lhs,self.map)else{return};
+letSome(conditions) = state.try_get_idx(lhs,&self.map)else{return};
 letSome(place) = self.map.find(place.as_ref())else{return};
 let conds = conditions.map(self.arena,Condition::inv);
- state.insert_value_idx(place, conds,self.map);
+ state.insert_value_idx(place, conds,&self.map);
 }
 // We expect `lhs ?= A`. We found `lhs = Eq(rhs, B)`.
 // Create a condition on `rhs ?= B`.
@@ -504,7 +502,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
  box (Operand::Move(place) | Operand::Copy(place),Operand::Constant(value))
  | box (Operand::Constant(value),Operand::Move(place) | Operand::Copy(place)),
 ) => {
-letSome(conditions) = state.try_get_idx(lhs,self.map)else{return};
+letSome(conditions) = state.try_get_idx(lhs,&self.map)else{return};
 letSome(place) = self.map.find(place.as_ref())else{return};
 let equals = match op {
 BinOp::Eq => ScalarInt::TRUE,
@@ -528,7 +526,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 polarity:if c.matches(equals){Polarity::Eq}else{Polarity::Ne},
  ..c
 });
- state.insert_value_idx(place, conds,self.map);
+ state.insert_value_idx(place, conds,&self.map);
 }
 
  _ => {}
@@ -583,7 +581,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(
 Operand::Copy(place) | Operand::Move(place),
 )) => {
-letSome(conditions) = state.try_get(place.as_ref(),self.map)else{return};
+letSome(conditions) = state.try_get(place.as_ref(),&self.map)else{return};
  conditions.iter_matches(ScalarInt::TRUE).for_each(register_opportunity);
 }
 StatementKind::Assign(box (lhs_place, rhs)) => {
@@ -631,7 +629,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 // We can recurse through this terminator.
 letmut state = state();
 ifletSome(place_to_flood) = place_to_flood {
- state.flood_with(place_to_flood.as_ref(),self.map,ConditionSet::BOTTOM);
+ state.flood_with(place_to_flood.as_ref(),&self.map,ConditionSet::BOTTOM);
 }
 self.find_opportunity(bb, state, cost.clone(), depth + 1);
 }
@@ -650,7 +648,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
 letSome(discr) = discr.place()else{return};
 let discr_ty = discr.ty(self.body,self.tcx).ty;
 letOk(discr_layout) = self.ecx.layout_of(discr_ty)else{return};
-letSome(conditions) = state.try_get(discr.as_ref(),self.map)else{return};
+letSome(conditions) = state.try_get(discr.as_ref(),&self.map)else{return};
 
 ifletSome((value, _)) = targets.iter().find(|&(_, target)| target == target_bb){
 letSome(value) = ScalarInt::try_from_uint(value, discr_layout.size)else{return};

compiler/rustc_mir_transform/src/lib.rs

@@ -223,24 +223,26 @@ fn is_mir_available(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
 /// MIR associated with them.
 fnmir_keys(tcx:TyCtxt<'_>,():()) -> FxIndexSet<LocalDefId>{
 // All body-owners have MIR associated with them.
-letmutset:FxIndexSet<_> = tcx.hir().body_owners().collect();
+let set:FxIndexSet<_> = tcx.hir().body_owners().collect();
 
 // Additionally, tuple struct/variant constructors have MIR, but
 // they don't have a BodyId, so we need to build them separately.
-structGatherCtors<'a>{
-set:&'amutFxIndexSet<LocalDefId>,
+structGatherCtors{
+set:FxIndexSet<LocalDefId>,
 }
-impl<'tcx>Visitor<'tcx>forGatherCtors<'_>{
+impl<'tcx>Visitor<'tcx>forGatherCtors{
 fnvisit_variant_data(&mutself,v:&'tcx hir::VariantData<'tcx>){
 iflet hir::VariantData::Tuple(_, _, def_id) = *v {
 self.set.insert(def_id);
 }
  intravisit::walk_struct_def(self, v)
 }
 }
- tcx.hir().visit_all_item_likes_in_crate(&mutGatherCtors{set:&mut set });
 
- set
+letmut gather_ctors = GatherCtors{ set };
+ tcx.hir().visit_all_item_likes_in_crate(&mut gather_ctors);
+
+ gather_ctors.set
 }
 
 fnmir_const_qualif(tcx:TyCtxt<'_>,def:LocalDefId) -> ConstQualifs{

compiler/rustc_mir_transform/src/mentioned_items.rs

@@ -10,7 +10,7 @@ pub(super) struct MentionedItems;
 structMentionedItemsVisitor<'a,'tcx>{
 tcx:TyCtxt<'tcx>,
 body:&'a mir::Body<'tcx>,
-mentioned_items:&'amutVec<Spanned<MentionedItem<'tcx>>>,
+mentioned_items:Vec<Spanned<MentionedItem<'tcx>>>,
 }
 
 impl<'tcx>crate::MirPass<'tcx>forMentionedItems{
@@ -23,9 +23,9 @@ impl<'tcx> crate::MirPass<'tcx> for MentionedItems {
 }
 
 fnrun_pass(&self,tcx:TyCtxt<'tcx>,body:&mut mir::Body<'tcx>){
-letmutmentioned_items = Vec::new();
-MentionedItemsVisitor{ tcx, body,mentioned_items:&mut mentioned_items }.visit_body(body);
- body.set_mentioned_items(mentioned_items);
+letmutvisitor = MentionedItemsVisitor{ tcx, body,mentioned_items:Vec::new()};
+visitor.visit_body(body);
+ body.set_mentioned_items(visitor.mentioned_items);
 }
 }
 

compiler/rustc_mir_transform/src/ref_prop.rs

@@ -253,11 +253,8 @@ fn compute_replacement<'tcx>(
 
 debug!(?targets);
 
-letmut finder = ReplacementFinder{
-targets:&mut targets,
- can_perform_opt,
-allowed_replacements:FxHashSet::default(),
-};
+letmut finder =
+ReplacementFinder{ targets, can_perform_opt,allowed_replacements:FxHashSet::default()};
 let reachable_blocks = traversal::reachable_as_bitset(body);
 for(bb, bbdata)in body.basic_blocks.iter_enumerated(){
 // Only visit reachable blocks as we rely on dataflow.
@@ -269,19 +266,19 @@ fn compute_replacement<'tcx>(
 let allowed_replacements = finder.allowed_replacements;
 returnReplacer{
  tcx,
- targets,
+targets: finder.targets,
  storage_to_remove,
  allowed_replacements,
 any_replacement:false,
 };
 
-structReplacementFinder<'a,'tcx,F>{
-targets:&'amutIndexVec<Local,Value<'tcx>>,
+structReplacementFinder<'tcx,F>{
+targets:IndexVec<Local,Value<'tcx>>,
 can_perform_opt:F,
 allowed_replacements:FxHashSet<(Local,Location)>,
 }
 
-impl<'tcx,F>Visitor<'tcx>forReplacementFinder<'_,'tcx,F>
+impl<'tcx,F>Visitor<'tcx>forReplacementFinder<'tcx,F>
 where
 F:FnMut(Place<'tcx>,Location) -> bool,
 {

compiler/rustc_mir_transform/src/required_consts.rs

@@ -1,26 +1,21 @@
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{traversal,Body,ConstOperand,Location};
 
-pub(super)structRequiredConstsVisitor<'a,'tcx>{
-required_consts:&'amutVec<ConstOperand<'tcx>>,
+pub(super)structRequiredConstsVisitor<'tcx>{
+required_consts:Vec<ConstOperand<'tcx>>,
 }
 
-impl<'a,'tcx>RequiredConstsVisitor<'a,'tcx>{
-fnnew(required_consts:&'amutVec<ConstOperand<'tcx>>) -> Self{
-RequiredConstsVisitor{ required_consts }
-}
-
+impl<'tcx>RequiredConstsVisitor<'tcx>{
 pub(super)fncompute_required_consts(body:&mutBody<'tcx>){
-letmut required_consts = Vec::new();
-letmut required_consts_visitor = RequiredConstsVisitor::new(&mut required_consts);
+letmut visitor = RequiredConstsVisitor{required_consts:Vec::new()};
 for(bb, bb_data)in traversal::reverse_postorder(&body){
-required_consts_visitor.visit_basic_block_data(bb, bb_data);
+visitor.visit_basic_block_data(bb, bb_data);
 }
- body.set_required_consts(required_consts);
+ body.set_required_consts(visitor.required_consts);
 }
 }
 
-impl<'tcx>Visitor<'tcx>forRequiredConstsVisitor<'_,'tcx>{
+impl<'tcx>Visitor<'tcx>forRequiredConstsVisitor<'tcx>{
 fnvisit_const_operand(&mutself,constant:&ConstOperand<'tcx>, _:Location){
 if constant.const_.is_required_const(){
 self.required_consts.push(*constant);