src/librustc_mir/hair/mod.rs

   1 //! The MIR is built from some high-level abstract IR
   2 //! (HAIR). This section defines the HAIR along with a trait for
   3 //! accessing it. The intention is to allow MIR construction to be
   4 //! unit-tested and separated from the Rust source and compiler data
   5 //! structures.
   6
   7 use rustc::mir::{BinOp, BorrowKind, Field, UnOp};
   8 use rustc::hir::def_id::DefId;
   9 use rustc::infer::canonical::Canonical;
  10 use rustc::middle::region;
  11 use rustc::ty::subst::SubstsRef;
  12 use rustc::ty::{AdtDef, UpvarSubsts, Ty, Const, UserType};
  13 use rustc::ty::adjustment::{PointerCast};
  14 use rustc::ty::layout::VariantIdx;
  15 use rustc::hir;
  16 use syntax_pos::Span;
  17 use self::cx::Cx;
  18
  19 pub mod cx;
  20 mod constant;
  21
  22 pub mod pattern;
  23 pub use self::pattern::{BindingMode, Pattern, PatternKind, PatternRange, FieldPattern};
  24 pub(crate) use self::pattern::PatternTypeProjection;
  25
  26 mod util;
  27
  28 #[derive(Copy, Clone, Debug)]
  29 pub enum LintLevel {
  30     Inherited,
  31     Explicit(hir::HirId)
  32 }
  33
  34 #[derive(Clone, Debug)]
  35 pub struct Block<'tcx> {
  36     pub targeted_by_break: bool,
  37     pub region_scope: region::Scope,
  38     pub opt_destruction_scope: Option<region::Scope>,
  39     pub span: Span,
  40     pub stmts: Vec<StmtRef<'tcx>>,
  41     pub expr: Option<ExprRef<'tcx>>,
  42     pub safety_mode: BlockSafety,
  43 }
  44
  45 #[derive(Copy, Clone, Debug)]
  46 pub enum BlockSafety {
  47     Safe,
  48     ExplicitUnsafe(hir::HirId),
  49     PushUnsafe,
  50     PopUnsafe
  51 }
  52
  53 #[derive(Clone, Debug)]
  54 pub enum StmtRef<'tcx> {
  55     Mirror(Box<Stmt<'tcx>>),
  56 }
  57
  58 #[derive(Clone, Debug)]
  59 pub struct Stmt<'tcx> {
  60     pub kind: StmtKind<'tcx>,
  61     pub opt_destruction_scope: Option<region::Scope>,
  62 }
  63
  64 #[derive(Clone, Debug)]
  65 pub enum StmtKind<'tcx> {
  66     Expr {
  67         /// scope for this statement; may be used as lifetime of temporaries
  68         scope: region::Scope,
  69
  70         /// expression being evaluated in this statement
  71         expr: ExprRef<'tcx>,
  72     },
  73
  74     Let {
  75         /// scope for variables bound in this let; covers this and
  76         /// remaining statements in block
  77         remainder_scope: region::Scope,
  78
  79         /// scope for the initialization itself; might be used as
  80         /// lifetime of temporaries
  81         init_scope: region::Scope,
  82
  83         /// `let <PAT> = ...`
  84         ///
  85         /// if a type is included, it is added as an ascription pattern
  86         pattern: Pattern<'tcx>,
  87
  88         /// let pat: ty = <INIT> ...
  89         initializer: Option<ExprRef<'tcx>>,
  90
  91         /// the lint level for this let-statement
  92         lint_level: LintLevel,
  93     },
  94 }
  95
  96 /// The Hair trait implementor lowers their expressions (`&'tcx H::Expr`)
  97 /// into instances of this `Expr` enum. This lowering can be done
  98 /// basically as lazily or as eagerly as desired: every recursive
  99 /// reference to an expression in this enum is an `ExprRef<'tcx>`, which
 100 /// may in turn be another instance of this enum (boxed), or else an
 101 /// unlowered `&'tcx H::Expr`. Note that instances of `Expr` are very
 102 /// short-lived. They are created by `Hair::to_expr`, analyzed and
 103 /// converted into MIR, and then discarded.
 104 ///
 105 /// If you compare `Expr` to the full compiler AST, you will see it is
 106 /// a good bit simpler. In fact, a number of the more straight-forward
 107 /// MIR simplifications are already done in the impl of `Hair`. For
 108 /// example, method calls and overloaded operators are absent: they are
 109 /// expected to be converted into `Expr::Call` instances.
 110 #[derive(Clone, Debug)]
 111 pub struct Expr<'tcx> {
 112     /// type of this expression
 113     pub ty: Ty<'tcx>,
 114
 115     /// lifetime of this expression if it should be spilled into a
 116     /// temporary; should be None only if in a constant context
 117     pub temp_lifetime: Option<region::Scope>,
 118
 119     /// span of the expression in the source
 120     pub span: Span,
 121
 122     /// kind of expression
 123     pub kind: ExprKind<'tcx>,
 124 }
 125
 126 #[derive(Clone, Debug)]
 127 pub enum ExprKind<'tcx> {
 128     Scope {
 129         region_scope: region::Scope,
 130         lint_level: LintLevel,
 131         value: ExprRef<'tcx>,
 132     },
 133     Box {
 134         value: ExprRef<'tcx>,
 135     },
 136     Call {
 137         ty: Ty<'tcx>,
 138         fun: ExprRef<'tcx>,
 139         args: Vec<ExprRef<'tcx>>,
 140         // Whether this is from a call in HIR, rather than from an overloaded
 141         // operator. True for overloaded function call.
 142         from_hir_call: bool,
 143     },
 144     Deref {
 145         arg: ExprRef<'tcx>,
 146     }, // NOT overloaded!
 147     Binary {
 148         op: BinOp,
 149         lhs: ExprRef<'tcx>,
 150         rhs: ExprRef<'tcx>,
 151     }, // NOT overloaded!
 152     LogicalOp {
 153         op: LogicalOp,
 154         lhs: ExprRef<'tcx>,
 155         rhs: ExprRef<'tcx>,
 156     }, // NOT overloaded!
 157        // LogicalOp is distinct from BinaryOp because of lazy evaluation of the operands.
 158     Unary {
 159         op: UnOp,
 160         arg: ExprRef<'tcx>,
 161     }, // NOT overloaded!
 162     Cast {
 163         source: ExprRef<'tcx>,
 164     },
 165     Use {
 166         source: ExprRef<'tcx>,
 167     }, // Use a lexpr to get a vexpr.
 168     NeverToAny {
 169         source: ExprRef<'tcx>,
 170     },
 171     Pointer {
 172         cast: PointerCast,
 173         source: ExprRef<'tcx>,
 174     },
 175     Loop {
 176         condition: Option<ExprRef<'tcx>>,
 177         body: ExprRef<'tcx>,
 178     },
 179     Match {
 180         scrutinee: ExprRef<'tcx>,
 181         arms: Vec<Arm<'tcx>>,
 182     },
 183     Block {
 184         body: &'tcx hir::Block,
 185     },
 186     Assign {
 187         lhs: ExprRef<'tcx>,
 188         rhs: ExprRef<'tcx>,
 189     },
 190     AssignOp {
 191         op: BinOp,
 192         lhs: ExprRef<'tcx>,
 193         rhs: ExprRef<'tcx>,
 194     },
 195     Field {
 196         lhs: ExprRef<'tcx>,
 197         name: Field,
 198     },
 199     Index {
 200         lhs: ExprRef<'tcx>,
 201         index: ExprRef<'tcx>,
 202     },
 203     VarRef {
 204         id: hir::HirId,
 205     },
 206     /// first argument, used for self in a closure
 207     SelfRef,
 208     StaticRef {
 209         id: DefId,
 210     },
 211     Borrow {
 212         borrow_kind: BorrowKind,
 213         arg: ExprRef<'tcx>,
 214     },
 215     Break {
 216         label: region::Scope,
 217         value: Option<ExprRef<'tcx>>,
 218     },
 219     Continue {
 220         label: region::Scope,
 221     },
 222     Return {
 223         value: Option<ExprRef<'tcx>>,
 224     },
 225     Repeat {
 226         value: ExprRef<'tcx>,
 227         count: u64,
 228     },
 229     Array {
 230         fields: Vec<ExprRef<'tcx>>,
 231     },
 232     Tuple {
 233         fields: Vec<ExprRef<'tcx>>,
 234     },
 235     Adt {
 236         adt_def: &'tcx AdtDef,
 237         variant_index: VariantIdx,
 238         substs: SubstsRef<'tcx>,
 239
 240         /// Optional user-given substs: for something like `let x =
 241         /// Bar::<T> { ... }`.
 242         user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
 243
 244         fields: Vec<FieldExprRef<'tcx>>,
 245         base: Option<FruInfo<'tcx>>
 246     },
 247     PlaceTypeAscription {
 248         source: ExprRef<'tcx>,
 249         /// Type that the user gave to this expression
 250         user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
 251     },
 252     ValueTypeAscription {
 253         source: ExprRef<'tcx>,
 254         /// Type that the user gave to this expression
 255         user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
 256     },
 257     Closure {
 258         closure_id: DefId,
 259         substs: UpvarSubsts<'tcx>,
 260         upvars: Vec<ExprRef<'tcx>>,
 261         movability: Option<hir::GeneratorMovability>,
 262     },
 263     Literal {
 264         literal: &'tcx Const<'tcx>,
 265         user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
 266     },
 267     InlineAsm {
 268         asm: &'tcx hir::InlineAsm,
 269         outputs: Vec<ExprRef<'tcx>>,
 270         inputs: Vec<ExprRef<'tcx>>
 271     },
 272     Yield {
 273         value: ExprRef<'tcx>,
 274     },
 275 }
 276
 277 #[derive(Clone, Debug)]
 278 pub enum ExprRef<'tcx> {
 279     Hair(&'tcx hir::Expr),
 280     Mirror(Box<Expr<'tcx>>),
 281 }
 282
 283 #[derive(Clone, Debug)]
 284 pub struct FieldExprRef<'tcx> {
 285     pub name: Field,
 286     pub expr: ExprRef<'tcx>,
 287 }
 288
 289 #[derive(Clone, Debug)]
 290 pub struct FruInfo<'tcx> {
 291     pub base: ExprRef<'tcx>,
 292     pub field_types: Vec<Ty<'tcx>>
 293 }
 294
 295 #[derive(Clone, Debug)]
 296 pub struct Arm<'tcx> {
 297     pub patterns: Vec<Pattern<'tcx>>,
 298     pub guard: Option<Guard<'tcx>>,
 299     pub body: ExprRef<'tcx>,
 300     pub lint_level: LintLevel,
 301     pub scope: region::Scope,
 302     pub span: Span,
 303 }
 304
 305 #[derive(Clone, Debug)]
 306 pub enum Guard<'tcx> {
 307     If(ExprRef<'tcx>),
 308 }
 309
 310 #[derive(Copy, Clone, Debug)]
 311 pub enum LogicalOp {
 312     And,
 313     Or,
 314 }
 315
 316 impl<'tcx> ExprRef<'tcx> {
 317     pub fn span(&self) -> Span {
 318         match self {
 319             ExprRef::Hair(expr) => expr.span,
 320             ExprRef::Mirror(expr) => expr.span,
 321         }
 322     }
 323 }
 324
 325 ///////////////////////////////////////////////////////////////////////////
 326 // The Mirror trait
 327
 328 /// "Mirroring" is the process of converting from a HIR type into one
 329 /// of the HAIR types defined in this file. This is basically a "on
 330 /// the fly" desugaring step that hides a lot of the messiness in the
 331 /// tcx. For example, the mirror of a `&'tcx hir::Expr` is an
 332 /// `Expr<'tcx>`.
 333 ///
 334 /// Mirroring is gradual: when you mirror an outer expression like `e1
 335 /// + e2`, the references to the inner expressions `e1` and `e2` are
 336 /// `ExprRef<'tcx>` instances, and they may or may not be eagerly
 337 /// mirrored. This allows a single AST node from the compiler to
 338 /// expand into one or more Hair nodes, which lets the Hair nodes be
 339 /// simpler.
 340 pub trait Mirror<'tcx> {
 341     type Output;
 342
 343     fn make_mirror(self, cx: &mut Cx<'_, 'tcx>) -> Self::Output;
 344 }
 345
 346 impl<'tcx> Mirror<'tcx> for Expr<'tcx> {
 347     type Output = Expr<'tcx>;
 348
 349     fn make_mirror(self, _: &mut Cx<'_, 'tcx>) -> Expr<'tcx> {
 350         self
 351     }
 352 }
 353
 354 impl<'tcx> Mirror<'tcx> for ExprRef<'tcx> {
 355     type Output = Expr<'tcx>;
 356
 357     fn make_mirror(self, hir: &mut Cx<'a, 'tcx>) -> Expr<'tcx> {
 358         match self {
 359             ExprRef::Hair(h) => h.make_mirror(hir),
 360             ExprRef::Mirror(m) => *m,
 361         }
 362     }
 363 }
 364
 365 impl<'tcx> Mirror<'tcx> for Stmt<'tcx> {
 366     type Output = Stmt<'tcx>;
 367
 368     fn make_mirror(self, _: &mut Cx<'_, 'tcx>) -> Stmt<'tcx> {
 369         self
 370     }
 371 }
 372
 373 impl<'tcx> Mirror<'tcx> for StmtRef<'tcx> {
 374     type Output = Stmt<'tcx>;
 375
 376     fn make_mirror(self, _: &mut Cx<'_, 'tcx>) -> Stmt<'tcx> {
 377         match self {
 378             StmtRef::Mirror(m) => *m,
 379         }
 380     }
 381 }
 382
 383 impl<'tcx> Mirror<'tcx> for Block<'tcx> {
 384     type Output = Block<'tcx>;
 385
 386     fn make_mirror(self, _: &mut Cx<'_, 'tcx>) -> Block<'tcx> {
 387         self
 388     }
 389 }