compiler/rustc_mir_build/src/thir/visit.rs

   1 use rustc_middle::thir::*;
   2 use rustc_middle::ty::Const;
   3
   4 pub trait Visitor<'a, 'tcx: 'a>: Sized {
   5     fn thir(&self) -> &'a Thir<'tcx>;
   6
   7     fn visit_expr(&mut self, expr: &Expr<'tcx>) {
   8         walk_expr(self, expr);
   9     }
  10
  11     fn visit_stmt(&mut self, stmt: &Stmt<'tcx>) {
  12         walk_stmt(self, stmt);
  13     }
  14
  15     fn visit_block(&mut self, block: &Block) {
  16         walk_block(self, block);
  17     }
  18
  19     fn visit_arm(&mut self, arm: &Arm<'tcx>) {
  20         walk_arm(self, arm);
  21     }
  22
  23     fn visit_const(&mut self, _cnst: &'tcx Const<'tcx>) {}
  24 }
  25
  26 pub fn walk_expr<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, expr: &Expr<'tcx>) {
  27     use ExprKind::*;
  28     match expr.kind {
  29         Scope { value, region_scope: _, lint_level: _ } => {
  30             visitor.visit_expr(&visitor.thir()[value])
  31         }
  32         Box { value } => visitor.visit_expr(&visitor.thir()[value]),
  33         If { cond, then, else_opt } => {
  34             visitor.visit_expr(&visitor.thir()[cond]);
  35             visitor.visit_expr(&visitor.thir()[then]);
  36             if let Some(else_expr) = else_opt {
  37                 visitor.visit_expr(&visitor.thir()[else_expr]);
  38             }
  39         }
  40         Call { fun, ref args, ty: _, from_hir_call: _, fn_span: _ } => {
  41             visitor.visit_expr(&visitor.thir()[fun]);
  42             for &arg in &**args {
  43                 visitor.visit_expr(&visitor.thir()[arg]);
  44             }
  45         }
  46         Deref { arg } => visitor.visit_expr(&visitor.thir()[arg]),
  47         Binary { lhs, rhs, op: _ } | LogicalOp { lhs, rhs, op: _ } => {
  48             visitor.visit_expr(&visitor.thir()[lhs]);
  49             visitor.visit_expr(&visitor.thir()[rhs]);
  50         }
  51         Unary { arg, op: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  52         Cast { source } => visitor.visit_expr(&visitor.thir()[source]),
  53         Use { source } => visitor.visit_expr(&visitor.thir()[source]),
  54         NeverToAny { source } => visitor.visit_expr(&visitor.thir()[source]),
  55         Pointer { source, cast: _ } => visitor.visit_expr(&visitor.thir()[source]),
  56         Loop { body } => visitor.visit_expr(&visitor.thir()[body]),
  57         Match { scrutinee, ref arms } => {
  58             visitor.visit_expr(&visitor.thir()[scrutinee]);
  59             for &arm in &**arms {
  60                 visitor.visit_arm(&visitor.thir()[arm]);
  61             }
  62         }
  63         Block { ref body } => visitor.visit_block(body),
  64         Assign { lhs, rhs } | AssignOp { lhs, rhs, op: _ } => {
  65             visitor.visit_expr(&visitor.thir()[lhs]);
  66             visitor.visit_expr(&visitor.thir()[rhs]);
  67         }
  68         Field { lhs, name: _ } => visitor.visit_expr(&visitor.thir()[lhs]),
  69         Index { lhs, index } => {
  70             visitor.visit_expr(&visitor.thir()[lhs]);
  71             visitor.visit_expr(&visitor.thir()[index]);
  72         }
  73         VarRef { id: _ } | UpvarRef { closure_def_id: _, var_hir_id: _ } => {}
  74         Borrow { arg, borrow_kind: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  75         AddressOf { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  76         Break { value, label: _ } => {
  77             if let Some(value) = value {
  78                 visitor.visit_expr(&visitor.thir()[value])
  79             }
  80         }
  81         Continue { label: _ } => {}
  82         Return { value } => {
  83             if let Some(value) = value {
  84                 visitor.visit_expr(&visitor.thir()[value])
  85             }
  86         }
  87         ConstBlock { value } => visitor.visit_const(value),
  88         Repeat { value, count } => {
  89             visitor.visit_expr(&visitor.thir()[value]);
  90             visitor.visit_const(count);
  91         }
  92         Array { ref fields } | Tuple { ref fields } => {
  93             for &field in &**fields {
  94                 visitor.visit_expr(&visitor.thir()[field]);
  95             }
  96         }
  97         Adt { ref fields, ref base, adt_def: _, variant_index: _, substs: _, user_ty: _ } => {
  98             for field in &**fields {
  99                 visitor.visit_expr(&visitor.thir()[field.expr]);
 100             }
 101             if let Some(base) = base {
 102                 visitor.visit_expr(&visitor.thir()[base.base]);
 103             }
 104         }
 105         PlaceTypeAscription { source, user_ty: _ } | ValueTypeAscription { source, user_ty: _ } => {
 106             visitor.visit_expr(&visitor.thir()[source])
 107         }
 108         Closure { closure_id: _, substs: _, upvars: _, movability: _, fake_reads: _ } => {}
 109         Literal { literal, user_ty: _, const_id: _ } => visitor.visit_const(literal),
 110         StaticRef { literal, def_id: _ } => visitor.visit_const(literal),
 111         InlineAsm { ref operands, template: _, options: _, line_spans: _ } => {
 112             for op in &**operands {
 113                 use InlineAsmOperand::*;
 114                 match op {
 115                     In { expr, reg: _ }
 116                     | Out { expr: Some(expr), reg: _, late: _ }
 117                     | InOut { expr, reg: _, late: _ }
 118                     | SymFn { expr } => visitor.visit_expr(&visitor.thir()[*expr]),
 119                     SplitInOut { in_expr, out_expr, reg: _, late: _ } => {
 120                         visitor.visit_expr(&visitor.thir()[*in_expr]);
 121                         if let Some(out_expr) = out_expr {
 122                             visitor.visit_expr(&visitor.thir()[*out_expr]);
 123                         }
 124                     }
 125                     Out { expr: None, reg: _, late: _ }
 126                     | Const { value: _, span: _ }
 127                     | SymStatic { def_id: _ } => {}
 128                 }
 129             }
 130         }
 131         ThreadLocalRef(_) => {}
 132         LlvmInlineAsm { ref outputs, ref inputs, asm: _ } => {
 133             for &out_expr in &**outputs {
 134                 visitor.visit_expr(&visitor.thir()[out_expr]);
 135             }
 136             for &in_expr in &**inputs {
 137                 visitor.visit_expr(&visitor.thir()[in_expr]);
 138             }
 139         }
 140         Yield { value } => visitor.visit_expr(&visitor.thir()[value]),
 141     }
 142 }
 143
 144 pub fn walk_stmt<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, stmt: &Stmt<'tcx>) {
 145     match stmt.kind {
 146         StmtKind::Expr { expr, scope: _ } => visitor.visit_expr(&visitor.thir()[expr]),
 147         StmtKind::Let {
 148             initializer,
 149             remainder_scope: _,
 150             init_scope: _,
 151             pattern: _,
 152             lint_level: _,
 153         } => {
 154             if let Some(init) = initializer {
 155                 visitor.visit_expr(&visitor.thir()[init]);
 156             }
 157         }
 158     }
 159 }
 160
 161 pub fn walk_block<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, block: &Block) {
 162     for &stmt in &*block.stmts {
 163         visitor.visit_stmt(&visitor.thir()[stmt]);
 164     }
 165     if let Some(expr) = block.expr {
 166         visitor.visit_expr(&visitor.thir()[expr]);
 167     }
 168 }
 169
 170 pub fn walk_arm<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, arm: &Arm<'tcx>) {
 171     match arm.guard {
 172         Some(Guard::If(expr)) => visitor.visit_expr(&visitor.thir()[expr]),
 173         Some(Guard::IfLet(ref _pat, expr)) => {
 174             visitor.visit_expr(&visitor.thir()[expr]);
 175         }
 176         None => {}
 177     }
 178     visitor.visit_expr(&visitor.thir()[arm.body]);
 179 }