compiler/rustc_mir_build/src/build/expr/category.rs

   1 use rustc_middle::thir::*;
   2
   3 #[derive(Debug, PartialEq)]
   4 crate enum Category {
   5     // An assignable memory location like `x`, `x.f`, `foo()[3]`, that
   6     // sort of thing. Something that could appear on the LHS of an `=`
   7     // sign.
   8     Place,
   9
  10     // A literal like `23` or `"foo"`. Does not include constant
  11     // expressions like `3 + 5`.
  12     Constant,
  13
  14     // Something that generates a new value at runtime, like `x + y`
  15     // or `foo()`.
  16     Rvalue(RvalueFunc),
  17 }
  18
  19 // Rvalues fall into different "styles" that will determine which fn
  20 // is best suited to generate them.
  21 #[derive(Debug, PartialEq)]
  22 crate enum RvalueFunc {
  23     // Best generated by `into`. This is generally exprs that
  24     // cause branching, like `match`, but also includes calls.
  25     Into,
  26
  27     // Best generated by `as_rvalue`. This is usually the case.
  28     AsRvalue,
  29 }
  30
  31 /// Determines the category for a given expression. Note that scope
  32 /// and paren expressions have no category.
  33 impl Category {
  34     crate fn of(ek: &ExprKind<'_>) -> Option<Category> {
  35         match *ek {
  36             ExprKind::Scope { .. } => None,
  37
  38             ExprKind::Field { .. }
  39             | ExprKind::Deref { .. }
  40             | ExprKind::Index { .. }
  41             | ExprKind::UpvarRef { .. }
  42             | ExprKind::VarRef { .. }
  43             | ExprKind::PlaceTypeAscription { .. }
  44             | ExprKind::ValueTypeAscription { .. } => Some(Category::Place),
  45
  46             ExprKind::LogicalOp { .. }
  47             | ExprKind::Match { .. }
  48             | ExprKind::If { .. }
  49             | ExprKind::NeverToAny { .. }
  50             | ExprKind::Use { .. }
  51             | ExprKind::Adt { .. }
  52             | ExprKind::Borrow { .. }
  53             | ExprKind::AddressOf { .. }
  54             | ExprKind::Yield { .. }
  55             | ExprKind::Call { .. }
  56             | ExprKind::InlineAsm { .. } => Some(Category::Rvalue(RvalueFunc::Into)),
  57
  58             ExprKind::Array { .. }
  59             | ExprKind::Tuple { .. }
  60             | ExprKind::Closure { .. }
  61             | ExprKind::Unary { .. }
  62             | ExprKind::Binary { .. }
  63             | ExprKind::Box { .. }
  64             | ExprKind::Cast { .. }
  65             | ExprKind::Pointer { .. }
  66             | ExprKind::Repeat { .. }
  67             | ExprKind::Assign { .. }
  68             | ExprKind::AssignOp { .. }
  69             | ExprKind::ThreadLocalRef(_)
  70             | ExprKind::LlvmInlineAsm { .. } => Some(Category::Rvalue(RvalueFunc::AsRvalue)),
  71
  72             ExprKind::ConstBlock { .. } | ExprKind::Literal { .. } | ExprKind::StaticRef { .. } => {
  73                 Some(Category::Constant)
  74             }
  75
  76             ExprKind::Loop { .. }
  77             | ExprKind::Block { .. }
  78             | ExprKind::Break { .. }
  79             | ExprKind::Continue { .. }
  80             | ExprKind::Return { .. } =>
  81             // FIXME(#27840) these probably want their own
  82             // category, like "nonterminating"
  83             {
  84                 Some(Category::Rvalue(RvalueFunc::Into))
  85             }
  86         }
  87     }
  88 }