Remove Elaborator.

It's a trivial wrapper around `ElaborateDropsCtxt` that serves no
apparent purpose.

Author: nnethercote

compiler/rustc_mir_transform/src/elaborate_drops.rs

@@ -137,45 +137,35 @@ impl InitializationData<'_, '_> {
 }
 }
 
-structElaborator<'a,'b,'tcx>{
-ctxt:&'amutElaborateDropsCtxt<'b,'tcx>,
-}
-
-impl fmt::DebugforElaborator<'_,'_,'_>{
-fnfmt(&self,_f:&mut fmt::Formatter<'_>) -> fmt::Result{
-Ok(())
-}
-}
-
-impl<'b,'tcx>DropElaborator<'b,'tcx>forElaborator<'_,'b,'tcx>{
+impl<'a,'tcx>DropElaborator<'a,'tcx>forElaborateDropsCtxt<'a,'tcx>{
 typePath = MovePathIndex;
 
 fnpatch(&mutself) -> &mutMirPatch<'tcx>{
-&mutself.ctxt.patch
+&mutself.patch
 }
 
-fnbody(&self) -> &'bBody<'tcx>{
-self.ctxt.body
+fnbody(&self) -> &'aBody<'tcx>{
+self.body
 }
 
 fntcx(&self) -> TyCtxt<'tcx>{
-self.ctxt.tcx
+self.tcx
 }
 
 fnparam_env(&self) -> ty::ParamEnv<'tcx>{
-self.ctxt.param_env()
+self.param_env()
 }
 
 #[instrument(level = "debug", skip(self), ret)]
 fndrop_style(&self,path:Self::Path,mode:DropFlagMode) -> DropStyle{
 let((maybe_live, maybe_dead), multipart) = match mode {
-DropFlagMode::Shallow => (self.ctxt.init_data.maybe_live_dead(path),false),
+DropFlagMode::Shallow => (self.init_data.maybe_live_dead(path),false),
 DropFlagMode::Deep => {
 letmut some_live = false;
 letmut some_dead = false;
 letmut children_count = 0;
-on_all_children_bits(self.ctxt.move_data(), path, |child| {
-let(live, dead) = self.ctxt.init_data.maybe_live_dead(child);
+on_all_children_bits(self.move_data(), path, |child| {
+let(live, dead) = self.init_data.maybe_live_dead(child);
 debug!("elaborate_drop: state({:?}) = {:?}", child,(live, dead));
  some_live |= live;
  some_dead |= dead;
@@ -195,25 +185,25 @@ impl<'b, 'tcx> DropElaborator<'b, 'tcx> for Elaborator<'_, 'b, 'tcx> {
 fnclear_drop_flag(&mutself,loc:Location,path:Self::Path,mode:DropFlagMode){
 match mode {
 DropFlagMode::Shallow => {
-self.ctxt.set_drop_flag(loc, path,DropFlagState::Absent);
+self.set_drop_flag(loc, path,DropFlagState::Absent);
 }
 DropFlagMode::Deep => {
-on_all_children_bits(self.ctxt.move_data(), path, |child| {
-self.ctxt.set_drop_flag(loc, child,DropFlagState::Absent)
+on_all_children_bits(self.move_data(), path, |child| {
+self.set_drop_flag(loc, child,DropFlagState::Absent)
 });
 }
 }
 }
 
 fnfield_subpath(&self,path:Self::Path,field:FieldIdx) -> Option<Self::Path>{
- rustc_mir_dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
+ rustc_mir_dataflow::move_path_children_matching(self.move_data(), path, |e| match e {
 ProjectionElem::Field(idx, _) => idx == field,
  _ => false,
 })
 }
 
 fnarray_subpath(&self,path:Self::Path,index:u64,size:u64) -> Option<Self::Path>{
- rustc_mir_dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
+ rustc_mir_dataflow::move_path_children_matching(self.move_data(), path, |e| match e {
 ProjectionElem::ConstantIndex{ offset, min_length, from_end } => {
 debug_assert!(size == min_length,"min_length should be exact for arrays");
 assert!(!from_end,"from_end should not be used for array element ConstantIndex");
@@ -224,20 +214,20 @@ impl<'b, 'tcx> DropElaborator<'b, 'tcx> for Elaborator<'_, 'b, 'tcx> {
 }
 
 fnderef_subpath(&self,path:Self::Path) -> Option<Self::Path>{
- rustc_mir_dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| {
+ rustc_mir_dataflow::move_path_children_matching(self.move_data(), path, |e| {
  e == ProjectionElem::Deref
 })
 }
 
 fndowncast_subpath(&self,path:Self::Path,variant:VariantIdx) -> Option<Self::Path>{
- rustc_mir_dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
+ rustc_mir_dataflow::move_path_children_matching(self.move_data(), path, |e| match e {
 ProjectionElem::Downcast(_, idx) => idx == variant,
  _ => false,
 })
 }
 
 fnget_drop_flag(&mutself,path:Self::Path) -> Option<Operand<'tcx>>{
-self.ctxt.drop_flag(path).map(Operand::Copy)
+self.drop_flag(path).map(Operand::Copy)
 }
 }
 
@@ -250,6 +240,12 @@ struct ElaborateDropsCtxt<'a, 'tcx> {
 patch:MirPatch<'tcx>,
 }
 
+impl fmt::DebugforElaborateDropsCtxt<'_,'_>{
+fnfmt(&self,_f:&mut fmt::Formatter<'_>) -> fmt::Result{
+Ok(())
+}
+}
+
 impl<'a,'tcx>ElaborateDropsCtxt<'a,'tcx>{
 fnmove_data(&self) -> &'aMoveData<'tcx>{
 &self.env.move_data
@@ -370,15 +366,7 @@ impl<'a, 'tcx> ElaborateDropsCtxt<'a, 'tcx> {
 }
 };
 self.init_data.seek_before(self.body.terminator_loc(bb));
-elaborate_drop(
-&mutElaborator{ctxt:self},
- terminator.source_info,
- place,
- path,
- target,
- unwind,
- bb,
-)
+elaborate_drop(self, terminator.source_info, place, path, target, unwind, bb)
 }
 LookupResult::Parent(None) => {}
 LookupResult::Parent(Some(_)) => {