1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! The MIR is translated from some high-level abstract IR
12 //! (HAIR). This section defines the HAIR along with a trait for
13 //! accessing it. The intention is to allow MIR construction to be
14 //! unit-tested and separated from the Rust source and compiler data
17 use rustc_const_math::ConstUsize;
18 use rustc::mir::{BinOp, BorrowKind, Field, Literal, UnOp};
19 use rustc::hir::def_id::DefId;
20 use rustc::middle::region;
21 use rustc::ty::subst::Substs;
22 use rustc::ty::{AdtDef, ClosureSubsts, Region, Ty, GeneratorInterior};
30 pub use rustc_const_eval::pattern::{BindingMode, Pattern, PatternKind, FieldPattern};
32 #[derive(Clone, Debug)]
33 pub struct Block<'tcx> {
34 pub targeted_by_break: bool,
35 pub region_scope: region::Scope,
36 pub opt_destruction_scope: Option<region::Scope>,
38 pub stmts: Vec<StmtRef<'tcx>>,
39 pub expr: Option<ExprRef<'tcx>>,
42 #[derive(Clone, Debug)]
43 pub enum StmtRef<'tcx> {
44 Mirror(Box<Stmt<'tcx>>),
47 #[derive(Clone, Debug)]
48 pub struct Stmt<'tcx> {
49 pub kind: StmtKind<'tcx>,
50 pub opt_destruction_scope: Option<region::Scope>,
53 #[derive(Clone, Debug)]
54 pub enum StmtKind<'tcx> {
56 /// scope for this statement; may be used as lifetime of temporaries
59 /// expression being evaluated in this statement
64 /// scope for variables bound in this let; covers this and
65 /// remaining statements in block
66 remainder_scope: region::Scope,
68 /// scope for the initialization itself; might be used as
69 /// lifetime of temporaries
70 init_scope: region::Scope,
73 pattern: Pattern<'tcx>,
75 /// let pat = <INIT> ...
76 initializer: Option<ExprRef<'tcx>>
80 /// The Hair trait implementor translates their expressions (`&'tcx H::Expr`)
81 /// into instances of this `Expr` enum. This translation can be done
82 /// basically as lazily or as eagerly as desired: every recursive
83 /// reference to an expression in this enum is an `ExprRef<'tcx>`, which
84 /// may in turn be another instance of this enum (boxed), or else an
85 /// untranslated `&'tcx H::Expr`. Note that instances of `Expr` are very
86 /// shortlived. They are created by `Hair::to_expr`, analyzed and
87 /// converted into MIR, and then discarded.
89 /// If you compare `Expr` to the full compiler AST, you will see it is
90 /// a good bit simpler. In fact, a number of the more straight-forward
91 /// MIR simplifications are already done in the impl of `Hair`. For
92 /// example, method calls and overloaded operators are absent: they are
93 /// expected to be converted into `Expr::Call` instances.
94 #[derive(Clone, Debug)]
95 pub struct Expr<'tcx> {
96 /// type of this expression
99 /// lifetime of this expression if it should be spilled into a
100 /// temporary; should be None only if in a constant context
101 pub temp_lifetime: Option<region::Scope>,
103 /// span of the expression in the source
106 /// kind of expression
107 pub kind: ExprKind<'tcx>,
110 #[derive(Clone, Debug)]
111 pub enum ExprKind<'tcx> {
113 region_scope: region::Scope,
114 value: ExprRef<'tcx>,
117 value: ExprRef<'tcx>,
122 args: Vec<ExprRef<'tcx>>,
126 }, // NOT overloaded!
131 }, // NOT overloaded!
136 }, // NOT overloaded!
137 // LogicalOp is distinct from BinaryOp because of lazy evaluation of the operands.
141 }, // NOT overloaded!
143 source: ExprRef<'tcx>,
146 source: ExprRef<'tcx>,
147 }, // Use a lexpr to get a vexpr.
149 source: ExprRef<'tcx>,
152 source: ExprRef<'tcx>,
155 source: ExprRef<'tcx>,
158 source: ExprRef<'tcx>,
161 source: ExprRef<'tcx>,
164 condition: ExprRef<'tcx>,
166 otherwise: Option<ExprRef<'tcx>>,
169 condition: Option<ExprRef<'tcx>>,
173 discriminant: ExprRef<'tcx>,
174 arms: Vec<Arm<'tcx>>,
177 body: &'tcx hir::Block,
194 index: ExprRef<'tcx>,
199 /// first argument, used for self in a closure
205 region: Region<'tcx>,
206 borrow_kind: BorrowKind,
210 label: region::Scope,
211 value: Option<ExprRef<'tcx>>,
214 label: region::Scope,
217 value: Option<ExprRef<'tcx>>,
220 value: ExprRef<'tcx>,
224 fields: Vec<ExprRef<'tcx>>,
227 fields: Vec<ExprRef<'tcx>>,
230 adt_def: &'tcx AdtDef,
231 variant_index: usize,
232 substs: &'tcx Substs<'tcx>,
233 fields: Vec<FieldExprRef<'tcx>>,
234 base: Option<FruInfo<'tcx>>
238 substs: ClosureSubsts<'tcx>,
239 upvars: Vec<ExprRef<'tcx>>,
240 interior: Option<GeneratorInterior<'tcx>>,
243 literal: Literal<'tcx>,
246 asm: &'tcx hir::InlineAsm,
247 outputs: Vec<ExprRef<'tcx>>,
248 inputs: Vec<ExprRef<'tcx>>
251 value: ExprRef<'tcx>,
255 #[derive(Clone, Debug)]
256 pub enum ExprRef<'tcx> {
257 Hair(&'tcx hir::Expr),
258 Mirror(Box<Expr<'tcx>>),
261 #[derive(Clone, Debug)]
262 pub struct FieldExprRef<'tcx> {
264 pub expr: ExprRef<'tcx>,
267 #[derive(Clone, Debug)]
268 pub struct FruInfo<'tcx> {
269 pub base: ExprRef<'tcx>,
270 pub field_types: Vec<Ty<'tcx>>
273 #[derive(Clone, Debug)]
274 pub struct Arm<'tcx> {
275 pub patterns: Vec<Pattern<'tcx>>,
276 pub guard: Option<ExprRef<'tcx>>,
277 pub body: ExprRef<'tcx>,
280 #[derive(Copy, Clone, Debug)]
286 ///////////////////////////////////////////////////////////////////////////
289 /// "Mirroring" is the process of converting from a HIR type into one
290 /// of the HAIR types defined in this file. This is basically a "on
291 /// the fly" desugaring step that hides a lot of the messiness in the
292 /// tcx. For example, the mirror of a `&'tcx hir::Expr` is an
295 /// Mirroring is gradual: when you mirror an outer expression like `e1
296 /// + e2`, the references to the inner expressions `e1` and `e2` are
297 /// `ExprRef<'tcx>` instances, and they may or may not be eagerly
298 /// mirrored. This allows a single AST node from the compiler to
299 /// expand into one or more Hair nodes, which lets the Hair nodes be
301 pub trait Mirror<'tcx> {
304 fn make_mirror<'a, 'gcx>(self, cx: &mut Cx<'a, 'gcx, 'tcx>) -> Self::Output;
307 impl<'tcx> Mirror<'tcx> for Expr<'tcx> {
308 type Output = Expr<'tcx>;
310 fn make_mirror<'a, 'gcx>(self, _: &mut Cx<'a, 'gcx, 'tcx>) -> Expr<'tcx> {
315 impl<'tcx> Mirror<'tcx> for ExprRef<'tcx> {
316 type Output = Expr<'tcx>;
318 fn make_mirror<'a, 'gcx>(self, hir: &mut Cx<'a, 'gcx, 'tcx>) -> Expr<'tcx> {
320 ExprRef::Hair(h) => h.make_mirror(hir),
321 ExprRef::Mirror(m) => *m,
326 impl<'tcx> Mirror<'tcx> for Stmt<'tcx> {
327 type Output = Stmt<'tcx>;
329 fn make_mirror<'a, 'gcx>(self, _: &mut Cx<'a, 'gcx, 'tcx>) -> Stmt<'tcx> {
334 impl<'tcx> Mirror<'tcx> for StmtRef<'tcx> {
335 type Output = Stmt<'tcx>;
337 fn make_mirror<'a, 'gcx>(self, _: &mut Cx<'a, 'gcx, 'tcx>) -> Stmt<'tcx> {
339 StmtRef::Mirror(m) => *m,
344 impl<'tcx> Mirror<'tcx> for Block<'tcx> {
345 type Output = Block<'tcx>;
347 fn make_mirror<'a, 'gcx>(self, _: &mut Cx<'a, 'gcx, 'tcx>) -> Block<'tcx> {