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::mir::repr::{BinOp, BorrowKind, Field, Literal, Mutability, UnOp, ItemKind};
18 use rustc::middle::const_eval::ConstVal;
19 use rustc::middle::def_id::DefId;
20 use rustc::middle::region::CodeExtent;
21 use rustc::middle::subst::Substs;
22 use rustc::middle::ty::{AdtDef, ClosureSubsts, Region, Ty};
25 use syntax::codemap::Span;
30 #[derive(Clone, Debug)]
31 pub struct ItemRef<'tcx> {
35 pub substs: &'tcx Substs<'tcx>,
38 #[derive(Clone, Debug)]
39 pub struct Block<'tcx> {
40 pub extent: CodeExtent,
42 pub stmts: Vec<StmtRef<'tcx>>,
43 pub expr: Option<ExprRef<'tcx>>,
46 #[derive(Clone, Debug)]
47 pub enum StmtRef<'tcx> {
48 Mirror(Box<Stmt<'tcx>>),
51 #[derive(Clone, Debug)]
52 pub struct Stmt<'tcx> {
54 pub kind: StmtKind<'tcx>,
57 #[derive(Clone, Debug)]
58 pub enum StmtKind<'tcx> {
60 /// scope for this statement; may be used as lifetime of temporaries
63 /// expression being evaluated in this statement
68 /// scope for variables bound in this let; covers this and
69 /// remaining statements in block
70 remainder_scope: CodeExtent,
72 /// scope for the initialization itself; might be used as
73 /// lifetime of temporaries
74 init_scope: CodeExtent,
77 pattern: Pattern<'tcx>,
79 /// let pat = <INIT> ...
80 initializer: Option<ExprRef<'tcx>>,
82 /// let pat = init; <STMTS>
83 stmts: Vec<StmtRef<'tcx>>,
87 // The Hair trait implementor translates their expressions (`&'tcx H::Expr`)
88 // into instances of this `Expr` enum. This translation can be done
89 // basically as lazilly or as eagerly as desired: every recursive
90 // reference to an expression in this enum is an `ExprRef<'tcx>`, which
91 // may in turn be another instance of this enum (boxed), or else an
92 // untranslated `&'tcx H::Expr`. Note that instances of `Expr` are very
93 // shortlived. They are created by `Hair::to_expr`, analyzed and
94 // converted into MIR, and then discarded.
96 // If you compare `Expr` to the full compiler AST, you will see it is
97 // a good bit simpler. In fact, a number of the more straight-forward
98 // MIR simplifications are already done in the impl of `Hair`. For
99 // example, method calls and overloaded operators are absent: they are
100 // expected to be converted into `Expr::Call` instances.
101 #[derive(Clone, Debug)]
102 pub struct Expr<'tcx> {
103 // type of this expression
106 // lifetime of this expression if it should be spilled into a
107 // temporary; should be None only if in a constant context
108 pub temp_lifetime: Option<CodeExtent>,
110 // span of the expression in the source
113 // kind of expression
114 pub kind: ExprKind<'tcx>,
117 #[derive(Clone, Debug)]
118 pub enum ExprKind<'tcx> {
121 value: ExprRef<'tcx>,
124 value: ExprRef<'tcx>,
128 args: Vec<ExprRef<'tcx>>,
132 }, // NOT overloaded!
137 }, // NOT overloaded!
146 }, // NOT overloaded!
148 source: ExprRef<'tcx>,
151 source: ExprRef<'tcx>,
154 source: ExprRef<'tcx>,
157 source: ExprRef<'tcx>,
160 condition: ExprRef<'tcx>,
162 otherwise: Option<ExprRef<'tcx>>,
165 condition: Option<ExprRef<'tcx>>,
169 discriminant: ExprRef<'tcx>,
170 arms: Vec<Arm<'tcx>>,
173 body: &'tcx hir::Block,
190 index: ExprRef<'tcx>,
195 SelfRef, // first argument, used for self in a closure
201 borrow_kind: BorrowKind,
205 label: Option<CodeExtent>,
208 label: Option<CodeExtent>,
211 value: Option<ExprRef<'tcx>>,
214 value: ExprRef<'tcx>,
215 // FIXME(#29789): Add a separate hair::Constant<'tcx> so this could be more explicit about
216 // its contained data. Currently this should only contain expression of ExprKind::Literal
218 count: ExprRef<'tcx>,
221 fields: Vec<ExprRef<'tcx>>,
224 fields: Vec<ExprRef<'tcx>>,
227 adt_def: AdtDef<'tcx>,
228 variant_index: usize,
229 substs: &'tcx Substs<'tcx>,
230 fields: Vec<FieldExprRef<'tcx>>,
231 base: Option<ExprRef<'tcx>>,
235 substs: &'tcx ClosureSubsts<'tcx>,
236 upvars: Vec<ExprRef<'tcx>>,
239 literal: Literal<'tcx>,
242 asm: &'tcx hir::InlineAsm,
246 #[derive(Clone, Debug)]
247 pub enum ExprRef<'tcx> {
248 Hair(&'tcx hir::Expr),
249 Mirror(Box<Expr<'tcx>>),
252 #[derive(Clone, Debug)]
253 pub struct FieldExprRef<'tcx> {
255 pub expr: ExprRef<'tcx>,
258 #[derive(Clone, Debug)]
259 pub struct Arm<'tcx> {
260 pub patterns: Vec<Pattern<'tcx>>,
261 pub guard: Option<ExprRef<'tcx>>,
262 pub body: ExprRef<'tcx>,
265 #[derive(Clone, Debug)]
266 pub struct Pattern<'tcx> {
269 pub kind: Box<PatternKind<'tcx>>,
272 #[derive(Copy, Clone, Debug)]
278 #[derive(Clone, Debug)]
279 pub enum PatternKind<'tcx> {
282 // x, ref x, x @ P, etc
284 mutability: Mutability,
289 subpattern: Option<Pattern<'tcx>>,
292 // Foo(...) or Foo{...} or Foo, where `Foo` is a variant name from an adt with >1 variants
294 adt_def: AdtDef<'tcx>,
295 variant_index: usize,
296 subpatterns: Vec<FieldPattern<'tcx>>,
299 // (...), Foo(...), Foo{...}, or Foo, where `Foo` is a variant name from an adt with 1 variant
301 subpatterns: Vec<FieldPattern<'tcx>>,
305 subpattern: Pattern<'tcx>,
306 }, // box P, &P, &mut P, etc
317 // matches against a slice, checking the length and extracting elements
319 prefix: Vec<Pattern<'tcx>>,
320 slice: Option<Pattern<'tcx>>,
321 suffix: Vec<Pattern<'tcx>>,
324 // fixed match against an array, irrefutable
326 prefix: Vec<Pattern<'tcx>>,
327 slice: Option<Pattern<'tcx>>,
328 suffix: Vec<Pattern<'tcx>>,
332 #[derive(Copy, Clone, Debug)]
333 pub enum BindingMode {
335 ByRef(Region, BorrowKind),
338 #[derive(Clone, Debug)]
339 pub struct FieldPattern<'tcx> {
341 pub pattern: Pattern<'tcx>,
344 ///////////////////////////////////////////////////////////////////////////
347 /// "Mirroring" is the process of converting from a HIR type into one
348 /// of the HAIR types defined in this file. This is basically a "on
349 /// the fly" desugaring step that hides a lot of the messiness in the
350 /// tcx. For example, the mirror of a `&'tcx hir::Expr` is an
353 /// Mirroring is gradual: when you mirror an outer expression like `e1
354 /// + e2`, the references to the inner expressions `e1` and `e2` are
355 /// `ExprRef<'tcx>` instances, and they may or may not be eagerly
356 /// mirrored. This allows a single AST node from the compiler to
357 /// expand into one or more Hair nodes, which lets the Hair nodes be
359 pub trait Mirror<'tcx> {
362 fn make_mirror<'a>(self, cx: &mut Cx<'a, 'tcx>) -> Self::Output;
365 impl<'tcx> Mirror<'tcx> for Expr<'tcx> {
366 type Output = Expr<'tcx>;
368 fn make_mirror<'a>(self, _: &mut Cx<'a, 'tcx>) -> Expr<'tcx> {
373 impl<'tcx> Mirror<'tcx> for ExprRef<'tcx> {
374 type Output = Expr<'tcx>;
376 fn make_mirror<'a>(self, hir: &mut Cx<'a, 'tcx>) -> Expr<'tcx> {
378 ExprRef::Hair(h) => h.make_mirror(hir),
379 ExprRef::Mirror(m) => *m,
384 impl<'tcx> Mirror<'tcx> for Stmt<'tcx> {
385 type Output = Stmt<'tcx>;
387 fn make_mirror<'a>(self, _: &mut Cx<'a, 'tcx>) -> Stmt<'tcx> {
392 impl<'tcx> Mirror<'tcx> for StmtRef<'tcx> {
393 type Output = Stmt<'tcx>;
395 fn make_mirror<'a>(self, _: &mut Cx<'a,'tcx>) -> Stmt<'tcx> {
397 StmtRef::Mirror(m) => *m,
402 impl<'tcx> Mirror<'tcx> for Block<'tcx> {
403 type Output = Block<'tcx>;
405 fn make_mirror<'a>(self, _: &mut Cx<'a, 'tcx>) -> Block<'tcx> {