compiler/rustc_mir_build/src/thir/visit.rs

   1 use rustc_middle::thir::{self, *};
   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_pat(&mut self, pat: &Pat<'tcx>) {
  24         walk_pat(self, pat);
  25     }
  26
  27     fn visit_const(&mut self, _cnst: &'tcx Const<'tcx>) {}
  28 }
  29
  30 pub fn walk_expr<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, expr: &Expr<'tcx>) {
  31     use ExprKind::*;
  32     match expr.kind {
  33         Scope { value, region_scope: _, lint_level: _ } => {
  34             visitor.visit_expr(&visitor.thir()[value])
  35         }
  36         Box { value } => visitor.visit_expr(&visitor.thir()[value]),
  37         If { cond, then, else_opt, if_then_scope: _ } => {
  38             visitor.visit_expr(&visitor.thir()[cond]);
  39             visitor.visit_expr(&visitor.thir()[then]);
  40             if let Some(else_expr) = else_opt {
  41                 visitor.visit_expr(&visitor.thir()[else_expr]);
  42             }
  43         }
  44         Call { fun, ref args, ty: _, from_hir_call: _, fn_span: _ } => {
  45             visitor.visit_expr(&visitor.thir()[fun]);
  46             for &arg in &**args {
  47                 visitor.visit_expr(&visitor.thir()[arg]);
  48             }
  49         }
  50         Deref { arg } => visitor.visit_expr(&visitor.thir()[arg]),
  51         Binary { lhs, rhs, op: _ } | LogicalOp { lhs, rhs, op: _ } => {
  52             visitor.visit_expr(&visitor.thir()[lhs]);
  53             visitor.visit_expr(&visitor.thir()[rhs]);
  54         }
  55         Unary { arg, op: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  56         Cast { source } => visitor.visit_expr(&visitor.thir()[source]),
  57         Use { source } => visitor.visit_expr(&visitor.thir()[source]),
  58         NeverToAny { source } => visitor.visit_expr(&visitor.thir()[source]),
  59         Pointer { source, cast: _ } => visitor.visit_expr(&visitor.thir()[source]),
  60         Let { expr, .. } => {
  61             visitor.visit_expr(&visitor.thir()[expr]);
  62         }
  63         Loop { body } => visitor.visit_expr(&visitor.thir()[body]),
  64         Match { scrutinee, ref arms } => {
  65             visitor.visit_expr(&visitor.thir()[scrutinee]);
  66             for &arm in &**arms {
  67                 visitor.visit_arm(&visitor.thir()[arm]);
  68             }
  69         }
  70         Block { ref body } => visitor.visit_block(body),
  71         Assign { lhs, rhs } | AssignOp { lhs, rhs, op: _ } => {
  72             visitor.visit_expr(&visitor.thir()[lhs]);
  73             visitor.visit_expr(&visitor.thir()[rhs]);
  74         }
  75         Field { lhs, name: _ } => visitor.visit_expr(&visitor.thir()[lhs]),
  76         Index { lhs, index } => {
  77             visitor.visit_expr(&visitor.thir()[lhs]);
  78             visitor.visit_expr(&visitor.thir()[index]);
  79         }
  80         VarRef { id: _ } | UpvarRef { closure_def_id: _, var_hir_id: _ } => {}
  81         Borrow { arg, borrow_kind: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  82         AddressOf { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]),
  83         Break { value, label: _ } => {
  84             if let Some(value) = value {
  85                 visitor.visit_expr(&visitor.thir()[value])
  86             }
  87         }
  88         Continue { label: _ } => {}
  89         Return { value } => {
  90             if let Some(value) = value {
  91                 visitor.visit_expr(&visitor.thir()[value])
  92             }
  93         }
  94         ConstBlock { value } => visitor.visit_const(value),
  95         Repeat { value, count } => {
  96             visitor.visit_expr(&visitor.thir()[value]);
  97             visitor.visit_const(count);
  98         }
  99         Array { ref fields } | Tuple { ref fields } => {
 100             for &field in &**fields {
 101                 visitor.visit_expr(&visitor.thir()[field]);
 102             }
 103         }
 104         Adt(box thir::Adt {
 105             ref fields,
 106             ref base,
 107             adt_def: _,
 108             variant_index: _,
 109             substs: _,
 110             user_ty: _,
 111         }) => {
 112             for field in &**fields {
 113                 visitor.visit_expr(&visitor.thir()[field.expr]);
 114             }
 115             if let Some(base) = base {
 116                 visitor.visit_expr(&visitor.thir()[base.base]);
 117             }
 118         }
 119         PlaceTypeAscription { source, user_ty: _ } | ValueTypeAscription { source, user_ty: _ } => {
 120             visitor.visit_expr(&visitor.thir()[source])
 121         }
 122         Closure { closure_id: _, substs: _, upvars: _, movability: _, fake_reads: _ } => {}
 123         Literal { literal, user_ty: _, const_id: _ } => visitor.visit_const(literal),
 124         StaticRef { literal, def_id: _ } => visitor.visit_const(literal),
 125         InlineAsm { ref operands, template: _, options: _, line_spans: _ } => {
 126             for op in &**operands {
 127                 use InlineAsmOperand::*;
 128                 match op {
 129                     In { expr, reg: _ }
 130                     | Out { expr: Some(expr), reg: _, late: _ }
 131                     | InOut { expr, reg: _, late: _ }
 132                     | SymFn { expr } => visitor.visit_expr(&visitor.thir()[*expr]),
 133                     SplitInOut { in_expr, out_expr, reg: _, late: _ } => {
 134                         visitor.visit_expr(&visitor.thir()[*in_expr]);
 135                         if let Some(out_expr) = out_expr {
 136                             visitor.visit_expr(&visitor.thir()[*out_expr]);
 137                         }
 138                     }
 139                     Out { expr: None, reg: _, late: _ }
 140                     | Const { value: _, span: _ }
 141                     | SymStatic { def_id: _ } => {}
 142                 }
 143             }
 144         }
 145         ThreadLocalRef(_) => {}
 146         LlvmInlineAsm { ref outputs, ref inputs, asm: _ } => {
 147             for &out_expr in &**outputs {
 148                 visitor.visit_expr(&visitor.thir()[out_expr]);
 149             }
 150             for &in_expr in &**inputs {
 151                 visitor.visit_expr(&visitor.thir()[in_expr]);
 152             }
 153         }
 154         Yield { value } => visitor.visit_expr(&visitor.thir()[value]),
 155     }
 156 }
 157
 158 pub fn walk_stmt<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, stmt: &Stmt<'tcx>) {
 159     match &stmt.kind {
 160         StmtKind::Expr { expr, scope: _ } => visitor.visit_expr(&visitor.thir()[*expr]),
 161         StmtKind::Let {
 162             initializer,
 163             remainder_scope: _,
 164             init_scope: _,
 165             ref pattern,
 166             lint_level: _,
 167         } => {
 168             if let Some(init) = initializer {
 169                 visitor.visit_expr(&visitor.thir()[*init]);
 170             }
 171             visitor.visit_pat(pattern);
 172         }
 173     }
 174 }
 175
 176 pub fn walk_block<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, block: &Block) {
 177     for &stmt in &*block.stmts {
 178         visitor.visit_stmt(&visitor.thir()[stmt]);
 179     }
 180     if let Some(expr) = block.expr {
 181         visitor.visit_expr(&visitor.thir()[expr]);
 182     }
 183 }
 184
 185 pub fn walk_arm<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, arm: &Arm<'tcx>) {
 186     match arm.guard {
 187         Some(Guard::If(expr)) => visitor.visit_expr(&visitor.thir()[expr]),
 188         Some(Guard::IfLet(ref pat, expr)) => {
 189             visitor.visit_pat(pat);
 190             visitor.visit_expr(&visitor.thir()[expr]);
 191         }
 192         None => {}
 193     }
 194     visitor.visit_pat(&arm.pattern);
 195     visitor.visit_expr(&visitor.thir()[arm.body]);
 196 }
 197
 198 pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'tcx>) {
 199     use PatKind::*;
 200     match pat.kind.as_ref() {
 201         AscribeUserType { subpattern, ascription: _ }
 202         | Deref { subpattern }
 203         | Binding {
 204             subpattern: Some(subpattern),
 205             mutability: _,
 206             mode: _,
 207             var: _,
 208             ty: _,
 209             is_primary: _,
 210             name: _,
 211         } => visitor.visit_pat(&subpattern),
 212         Binding { .. } | Wild => {}
 213         Variant { subpatterns, adt_def: _, substs: _, variant_index: _ } | Leaf { subpatterns } => {
 214             for subpattern in subpatterns {
 215                 visitor.visit_pat(&subpattern.pattern);
 216             }
 217         }
 218         Constant { value } => visitor.visit_const(value),
 219         Range(range) => {
 220             visitor.visit_const(range.lo);
 221             visitor.visit_const(range.hi);
 222         }
 223         Slice { prefix, slice, suffix } | Array { prefix, slice, suffix } => {
 224             for subpattern in prefix {
 225                 visitor.visit_pat(&subpattern);
 226             }
 227             if let Some(pat) = slice {
 228                 visitor.visit_pat(pat);
 229             }
 230             for subpattern in suffix {
 231                 visitor.visit_pat(&subpattern);
 232             }
 233         }
 234         Or { pats } => {
 235             for pat in pats {
 236                 visitor.visit_pat(&pat);
 237             }
 238         }
 239     };
 240 }