Skip to content

Commit

Permalink
Auto merge of #31324 - nagisa:mir-transforms, r=nikomatsakis
Browse files Browse the repository at this point in the history 
Having a `MirPass` provides literally no benefits over `MutVisitor`. Moreover using `MirPass` for
`EraseRegions` basically makes the programmer to fix breakage from changing repr twice – in the
visitor and eraseregions. Since `MutVisitor` implements all the “walking” inside the trait, that can
be reused for `EraseRegions` too, basically resulting in less code duplication.
  • Loading branch information
@bors
bors committed Feb 8, 2016
2 parents 26105b1 + 0b3ef97 commit efdde24
Show file tree
Hide file tree
Showing 2 changed files with 68 additions and 158 deletions.
2 changes: 1 addition & 1 deletion src/librustc_mir/mir_map.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,7 @@ extern crate rustc_front;
use build;
use graphviz;
use pretty;
use transform::*;
use transform::{simplify_cfg, MirPass};
use rustc::dep_graph::DepNode;
use rustc::mir::repr::Mir;
use hair::cx::Cx;
Expand Down
224 changes: 67 additions & 157 deletions src/librustc_mir/transform/erase_regions.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,9 @@
use rustc::middle::ty;
use rustc::mir::repr::*;
use transform::MirPass;
use rustc::mir::visit::MutVisitor;
use mir_map::MirMap;
use transform::MirPass;

pub fn erase_regions<'tcx>(tcx: &ty::ctxt<'tcx>, mir_map: &mut MirMap<'tcx>) {
let mut eraser = EraseRegions::new(tcx);
Expand All @@ -29,196 +30,105 @@ pub struct EraseRegions<'a, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
}

impl<'a, 'tcx> MirPass<'tcx> for EraseRegions<'a, 'tcx> {

fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {

for basic_block in &mut mir.basic_blocks {
self.erase_regions_basic_block(basic_block);
}

self.erase_regions_return_ty(&mut mir.return_ty);

self.erase_regions_tys(mir.var_decls.iter_mut().map(|d| &mut d.ty));
self.erase_regions_tys(mir.arg_decls.iter_mut().map(|d| &mut d.ty));
self.erase_regions_tys(mir.temp_decls.iter_mut().map(|d| &mut d.ty));
}
}

impl<'a, 'tcx> EraseRegions<'a, 'tcx> {

pub fn new(tcx: &'a ty::ctxt<'tcx>) -> EraseRegions<'a, 'tcx> {
EraseRegions {
tcx: tcx
}
}

fn erase_regions_basic_block(&mut self,
basic_block: &mut BasicBlockData<'tcx>) {
for statement in &mut basic_block.statements {
self.erase_regions_statement(statement);
fn erase_regions_return_ty(&mut self, fn_output: &mut ty::FnOutput<'tcx>) {
match *fn_output {
ty::FnConverging(ref mut ty) => {
*ty = self.tcx.erase_regions(ty);
},
ty::FnDiverging => {}
}

self.erase_regions_terminator(basic_block.terminator_mut());
}

fn erase_regions_statement(&mut self,
statement: &mut Statement<'tcx>) {
match statement.kind {
StatementKind::Assign(ref mut lvalue, ref mut rvalue) => {
self.erase_regions_lvalue(lvalue);
self.erase_regions_rvalue(rvalue);
}
fn erase_regions_tys<'b, T>(&mut self, tys: T)
where T: Iterator<Item = &'b mut ty::Ty<'tcx>>,
'tcx: 'b
{
for ty in tys {
*ty = self.tcx.erase_regions(ty);
}
}
}

impl<'a, 'tcx> MirPass<'tcx> for EraseRegions<'a, 'tcx> {
fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {
self.visit_mir(mir);
}
}

fn erase_regions_terminator(&mut self,
terminator: &mut Terminator<'tcx>) {
impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegions<'a, 'tcx> {
fn visit_mir(&mut self, mir: &mut Mir<'tcx>) {
self.erase_regions_return_ty(&mut mir.return_ty);
self.erase_regions_tys(mir.var_decls.iter_mut().map(|d| &mut d.ty));
self.erase_regions_tys(mir.arg_decls.iter_mut().map(|d| &mut d.ty));
self.erase_regions_tys(mir.temp_decls.iter_mut().map(|d| &mut d.ty));
self.super_mir(mir);
}

fn visit_terminator(&mut self, bb: BasicBlock, terminator: &mut Terminator<'tcx>) {
match *terminator {
Terminator::Goto { .. } |
Terminator::Resume |
Terminator::Return => {
Terminator::Return |
Terminator::If { .. } |
Terminator::Switch { .. } |
Terminator::Drop { .. } |
Terminator::Call { .. } => {
/* nothing to do */
}
Terminator::If { ref mut cond, .. } => {
self.erase_regions_operand(cond);
}
Terminator::Switch { ref mut discr, .. } => {
self.erase_regions_lvalue(discr);
}
Terminator::SwitchInt { ref mut discr, ref mut switch_ty, .. } => {
self.erase_regions_lvalue(discr);
},
Terminator::SwitchInt { ref mut switch_ty, .. } => {
*switch_ty = self.tcx.erase_regions(switch_ty);
},
Terminator::Drop { ref mut value, .. } => {
self.erase_regions_lvalue(value);
}
Terminator::Call { ref mut func, ref mut args, ref mut destination, .. } => {
if let Some((ref mut destination, _)) = *destination {
self.erase_regions_lvalue(destination);
}
self.erase_regions_operand(func);
for arg in &mut *args {
self.erase_regions_operand(arg);
}
}
}
}

fn erase_regions_operand(&mut self, operand: &mut Operand<'tcx>) {
match *operand {
Operand::Consume(ref mut lvalue) => {
self.erase_regions_lvalue(lvalue);
}
Operand::Constant(ref mut constant) => {
self.erase_regions_constant(constant);
}
}
}

fn erase_regions_lvalue(&mut self, lvalue: &mut Lvalue<'tcx>) {
match *lvalue {
Lvalue::Var(_) |
Lvalue::Temp(_) |
Lvalue::Arg(_) |
Lvalue::Static(_) |
Lvalue::ReturnPointer => {}
Lvalue::Projection(ref mut lvalue_projection) => {
self.erase_regions_lvalue(&mut lvalue_projection.base);
match lvalue_projection.elem {
ProjectionElem::Deref |
ProjectionElem::Field(_) |
ProjectionElem::Downcast(..) |
ProjectionElem::ConstantIndex {..} => { /* nothing to do */ }
ProjectionElem::Index(ref mut index) => {
self.erase_regions_operand(index);
}
}
}
}
self.super_terminator(bb, terminator);
}

fn erase_regions_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
match *rvalue {
Rvalue::Use(ref mut operand) => {
self.erase_regions_operand(operand)
}
Rvalue::Repeat(ref mut operand, ref mut value) => {
self.erase_regions_operand(operand);
value.ty = self.tcx.erase_regions(&value.ty);
}
Rvalue::Ref(ref mut region, _, ref mut lvalue) => {
*region = ty::ReStatic;
self.erase_regions_lvalue(lvalue);
}
Rvalue::Len(ref mut lvalue) => self.erase_regions_lvalue(lvalue),
Rvalue::Cast(_, ref mut operand, ref mut ty) => {
self.erase_regions_operand(operand);
*ty = self.tcx.erase_regions(ty);
}
Rvalue::BinaryOp(_, ref mut operand1, ref mut operand2) => {
self.erase_regions_operand(operand1);
self.erase_regions_operand(operand2);
}
Rvalue::UnaryOp(_, ref mut operand) => {
self.erase_regions_operand(operand);
}
Rvalue::Use(_) |
Rvalue::Len(_) |
Rvalue::BinaryOp(_, _, _) |
Rvalue::UnaryOp(_, _) |
Rvalue::Slice { input: _, from_start: _, from_end: _ } |
Rvalue::InlineAsm(_) => {},

Rvalue::Repeat(_, ref mut value) => value.ty = self.tcx.erase_regions(&value.ty),
Rvalue::Ref(ref mut region, _, _) => *region = ty::ReStatic,
Rvalue::Cast(_, _, ref mut ty) => *ty = self.tcx.erase_regions(ty),
Rvalue::Box(ref mut ty) => *ty = self.tcx.erase_regions(ty),
Rvalue::Aggregate(ref mut aggregate_kind, ref mut operands) => {
match *aggregate_kind {
AggregateKind::Vec |
AggregateKind::Tuple => {},
AggregateKind::Adt(_, _, ref mut substs) => {
let erased = self.tcx.erase_regions(*substs);
*substs = self.tcx.mk_substs(erased);
}
AggregateKind::Closure(def_id, ref mut closure_substs) => {
let cloned = Box::new(closure_substs.clone());
let ty = self.tcx.mk_closure_from_closure_substs(def_id,
cloned);
let erased = self.tcx.erase_regions(&ty);
*closure_substs = match erased.sty {
ty::TyClosure(_, ref closure_substs) => &*closure_substs,
_ => unreachable!()
};
}
}
for operand in &mut *operands {
self.erase_regions_operand(operand);
}
}
Rvalue::Slice { ref mut input, .. } => {
self.erase_regions_lvalue(input);


Rvalue::Aggregate(AggregateKind::Vec, _) |
Rvalue::Aggregate(AggregateKind::Tuple, _) => {},
Rvalue::Aggregate(AggregateKind::Adt(_, _, ref mut substs), _) =>
*substs = self.tcx.mk_substs(self.tcx.erase_regions(*substs)),
Rvalue::Aggregate(AggregateKind::Closure(def_id, ref mut closure_substs), _) => {
let cloned = Box::new(closure_substs.clone());
let ty = self.tcx.mk_closure_from_closure_substs(def_id, cloned);
let erased = self.tcx.erase_regions(&ty);
*closure_substs = match erased.sty {
ty::TyClosure(_, ref closure_substs) => &*closure_substs,
_ => unreachable!()
};
}
Rvalue::InlineAsm(_) => {},
}
self.super_rvalue(rvalue);
}

fn erase_regions_constant(&mut self, constant: &mut Constant<'tcx>) {
fn visit_constant(&mut self, constant: &mut Constant<'tcx>) {
constant.ty = self.tcx.erase_regions(&constant.ty);
match constant.literal {
Literal::Item { ref mut substs, .. } => {
*substs = self.tcx.mk_substs(self.tcx.erase_regions(substs));
}
Literal::Value { .. } => { /* nothing to do */ }
}
}

fn erase_regions_return_ty(&mut self, fn_output: &mut ty::FnOutput<'tcx>) {
match *fn_output {
ty::FnConverging(ref mut ty) => {
*ty = self.tcx.erase_regions(ty);
},
ty::FnDiverging => {}
}
}

fn erase_regions_tys<'b, T>(&mut self, tys: T)
where T: Iterator<Item = &'b mut ty::Ty<'tcx>>,
'tcx: 'b
{
for ty in tys {
*ty = self.tcx.erase_regions(ty);
}
self.super_constant(constant);
}
}

0 comments on commit efdde24

Please sign in to comment.