Module rustc_mir::build[][src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Re-exports

use build;
use hair::cx::Cx;
use hair::LintLevel;
use hair::BindingMode;
use hair::PatternKind;
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::hir::def_id::LocalDefId;
use rustc::middle::region;
use rustc::mir::*;
use rustc::mir::visit::MutVisitor;
use rustc::mir::visit::TyContext;
use rustc::ty;
use rustc::ty::Ty;
use rustc::ty::TyCtxt;
use rustc::ty::subst::Substs;
use rustc::util::nodemap::NodeMap;
use rustc_target::spec::PanicStrategy;
use rustc_data_structures::indexed_vec::IndexVec;
use rustc_data_structures::indexed_vec::Idx;
use shim;
use std::mem;
use std::u32;
use rustc_target::spec::abi::Abi;
use syntax::ast;
use syntax::attr;
use syntax::attr::UnwindAttr;
use syntax::symbol::keywords;
use syntax_pos::Span;
use transform::MirSource;
use util as mir_util;

Modules

block [
Experimental
]
cfg [
Experimental
]

Routines for manipulating the control-flow graph.

expr [
Experimental
]

Translates expressions into MIR. As a caller into this module, you have many options, but the first thing you have to decide is whether you are evaluating this expression for its value, its location, or as a constant.

into [
Experimental
]

In general, there are a number of things for which it's convenient to just call builder.into and have it emit its result into a given location. This is basically for expressions or things that can be wrapped up as expressions (e.g. blocks). To make this ergonomic, we use this latter EvalInto trait.

matches [
Experimental
]

Code related to match expressions. These are sufficiently complex to warrant their own module and submodules. :) This main module includes the high-level algorithm, the submodules contain the details.

misc [
Experimental
]

Miscellaneous builder routines that are not specific to building any particular kind of thing.

scope [
Experimental
]

Managing the scope stack. The scopes are tied to lexical scopes, so as we descend the HAIR, we push a scope on the stack, translate ite contents, and then pop it off. Every scope is named by a region::Scope.

Structs

BlockAnd [
Experimental
]

The BlockAnd "monad" packages up the new basic block along with a produced value (sometimes just unit, of course). The unpack! macro (and methods below) makes working with BlockAnd much more convenient.

Builder [
Experimental
]
CFG [
Experimental
]
GlobalizeMir [
Experimental
]

A pass to lift all the types and substitutions in a Mir to the global tcx. Sadly, we don't have a "folder" that can change 'tcx so we have to transmute afterwards.

GuardFrame [
Experimental
]
GuardFrameLocal [
Experimental
]
ScopeId [
Experimental
]

Enums

ForGuard [
Experimental
]

ForGuard is isomorphic to a boolean flag. It indicates whether we are talking about the temp for a local binding for a use within a guard expression, or a temp for use outside of a guard expressions.

LocalsForNode [
Experimental
]

Traits

BlockAndExtension [
Experimental
]

Functions

construct_const [
Experimental
]
construct_error [
Experimental
]
construct_fn [
Experimental
]

the main entry point for building MIR for a function

create_constructor_shim [
Experimental
]
liberated_closure_env_ty [
Experimental
]
mir_build [
Experimental
]

Construct the MIR for a given def-id.

should_abort_on_panic [
Experimental
]