mir_map.rs

// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! An experimental pass that scources for `#[rustc_mir]` attributes,
//! builds the resulting MIR, and dumps it out into a file for inspection.
//!
//! The attribute formats that are currently accepted are:
//!
//! - `#[rustc_mir(graphviz="file.gv")]`
//! - `#[rustc_mir(pretty="file.mir")]`

use build;
use rustc::dep_graph::DepNode;
use rustc::hir::def_id::DefId;
use rustc::hir::map as hir_map;
use rustc::mir::Mir;
use rustc::mir::transform::MirSource;
use rustc::mir::visit::MutVisitor;
use pretty;
use hair::cx::Cx;

use rustc::infer::InferCtxtBuilder;
use rustc::traits::Reveal;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::demand::{Provider, Unsupported};
use rustc::ty::subst::Substs;
use rustc::hir;
use rustc::hir::intravisit::{self, Visitor};
use syntax::abi::Abi;
use syntax::ast;
use syntax_pos::Span;

use std::cell::RefCell;
use std::mem;

pub fn demand_mir_for_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
    tcx.visit_all_items_in_krate(DepNode::Mir, &mut DemandMir {
        tcx: tcx
    });
}

/// 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.
struct GlobalizeMir<'a, 'gcx: 'a> {
    tcx: TyCtxt<'a, 'gcx, 'gcx>,
    span: Span
}

impl<'a, 'gcx: 'tcx, 'tcx> MutVisitor<'tcx> for GlobalizeMir<'a, 'gcx> {
    fn visit_ty(&mut self, ty: &mut Ty<'tcx>) {
        if let Some(lifted) = self.tcx.lift(ty) {
            *ty = lifted;
        } else {
            span_bug!(self.span,
                      "found type `{:?}` with inference types/regions in MIR",
                      ty);
        }
    }

    fn visit_substs(&mut self, substs: &mut &'tcx Substs<'tcx>) {
        if let Some(lifted) = self.tcx.lift(substs) {
            *substs = lifted;
        } else {
            span_bug!(self.span,
                      "found substs `{:?}` with inference types/regions in MIR",
                      substs);
        }
    }
}

/// Helper type of a temporary returned by cx(tcx, id).
/// Necessary because we can't write the following bound:
/// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Cx<'b, 'gcx, 'tcx>).
struct CxBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
    id: ast::NodeId,
    infcx: InferCtxtBuilder<'a, 'gcx, 'tcx>
}

fn cx<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, id: ast::NodeId)
                      -> CxBuilder<'a, 'gcx, 'tcx> {
    let param_env = ty::ParameterEnvironment::for_item(tcx, id);
    CxBuilder {
        id: id,
        infcx: tcx.infer_ctxt(None, Some(param_env), Reveal::NotSpecializable)
    }
}

impl<'a, 'gcx, 'tcx> CxBuilder<'a, 'gcx, 'tcx> {
    fn build<F>(&'tcx mut self, f: F) -> &'gcx RefCell<Mir<'gcx>>
        where F: for<'b> FnOnce(Cx<'b, 'gcx, 'tcx>) -> (Mir<'tcx>, build::ScopeAuxiliaryVec)
    {
        let id = self.id;
        self.infcx.enter(|infcx| {
            let tcx = infcx.tcx.global_tcx();
            let src = MirSource::from_node(tcx, id);
            let (mut mir, scope_auxiliary) = f(Cx::new(&infcx, src));

            // Convert the Mir to global types.
            let mut globalizer = GlobalizeMir {
                tcx: tcx,
                span: mir.span
            };
            globalizer.visit_mir(&mut mir);
            let mir = unsafe {
                mem::transmute::<Mir, Mir<'gcx>>(mir)
            };

            pretty::dump_mir(tcx, "mir_map", &0, src, &mir, Some(&scope_auxiliary));

            let mir = tcx.alloc_mir(mir);
            tcx.mir_map.borrow_mut().insert(tcx.map.local_def_id(id), mir);
            mir
        })
    }

    fn build_const(&'tcx mut self, expr: &'gcx hir::Expr) -> &'gcx RefCell<Mir<'gcx>> {
        let id = self.id;
        self.build(|cx| build::construct_const(cx, id, expr))
    }

    fn build_fn(&'tcx mut self, decl: &'gcx hir::FnDecl, body: &'gcx hir::Expr)
                 -> &'gcx RefCell<Mir<'gcx>> {
        let id = self.id;
        self.build(|cx| {
            let tcx = cx.tcx().global_tcx();

            // fetch the fully liberated fn signature (that is, all bound
            // types/lifetimes replaced)
            let fn_sig = match tcx.tables().liberated_fn_sigs.get(&id) {
                Some(f) => f.clone(),
                None => {
                    let span = tcx.map.span(id);
                    span_bug!(span, "no liberated fn sig for {:?}", id);
                }
            };

            let node = tcx.map.get(id);
            let (abi, implicit_argument) = if let hir_map::NodeExpr(_) = node {
                (Abi::Rust, Some((closure_self_ty(tcx, id, body.id), None)))
            } else {
                let def_id = tcx.map.local_def_id(id);
                (tcx.item_type(def_id).fn_abi(), None)
            };

            let explicit_arguments =
                decl.inputs
                    .iter()
                    .enumerate()
                    .map(|(index, arg)| {
                        (fn_sig.inputs[index], Some(&*arg.pat))
                    });

            let arguments = implicit_argument.into_iter().chain(explicit_arguments);
            build::construct_fn(cx, id, arguments, abi, fn_sig.output, body)
        })
    }
}

pub struct MirProvider;

impl<'tcx> Provider<'tcx> for MirProvider {
    fn mir<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
               -> Result<&'tcx RefCell<Mir<'tcx>>, Unsupported> {
        let id = if let Some(id) = tcx.map.as_local_node_id(def_id) {
            id
        } else {
            return Err(Unsupported);
        };

        let mut cx = cx(tcx, id);
        match tcx.map.get(id) {
            hir_map::NodeItem(item) => {
                match item.node {
                    hir::ItemConst(_, ref expr) |
                    hir::ItemStatic(_, _, ref expr) => {
                        Ok(cx.build_const(expr))
                    }
                    hir::ItemFn(ref decl, _, _, _, _, ref body) => {
                        Ok(cx.build_fn(decl, body))
                    }
                    _ => Err(Unsupported)
                }
            }
            hir_map::NodeTraitItem(item) => {
                match item.node {
                    hir::ConstTraitItem(_, Some(ref expr)) => {
                        Ok(cx.build_const(expr))
                    }
                    hir::MethodTraitItem(ref sig, Some(ref body)) => {
                        Ok(cx.build_fn(&sig.decl, body))
                    }
                    _ => Err(Unsupported)
                }
            }
            hir_map::NodeImplItem(item) => {
                match item.node {
                    hir::ImplItemKind::Const(_, ref expr) => {
                        Ok(cx.build_const(expr))
                    }
                    hir::ImplItemKind::Method(ref sig, ref body) => {
                        Ok(cx.build_fn(&sig.decl, body))
                    }
                    _ => Err(Unsupported)
                }
            }
            hir_map::NodeExpr(expr) => {
                // FIXME(eddyb) Closures should have separate
                // function definition IDs and expression IDs.
                // Type-checking should not let closures get
                // this far in a constant position.
                // Assume that everything other than closures
                // is a constant "initializer" expression.
                match expr.node {
                    hir::ExprClosure(_, ref decl, ref body, _) => {
                        Ok(cx.build_fn(decl, body))
                    }
                    _ => Ok(cx.build_const(expr))
                }
            }
            _ => Err(Unsupported)
        }
    }
}

///////////////////////////////////////////////////////////////////////////
// DemandMir -- walks a crate, looking for fn items and methods to build MIR from

struct DemandMir<'a, 'tcx: 'a> {
    tcx: TyCtxt<'a, 'tcx, 'tcx>
}

impl<'a, 'tcx> DemandMir<'a, 'tcx> {
    fn demand(&self, id: ast::NodeId) {
        self.tcx.item_mir(self.tcx.map.local_def_id(id));
    }
}

impl<'a, 'tcx> Visitor<'tcx> for DemandMir<'a, 'tcx> {
    // Const and static items.
    fn visit_item(&mut self, item: &'tcx hir::Item) {
        match item.node {
            hir::ItemConst(..) |
            hir::ItemStatic(..) |
            hir::ItemFn(..) => self.demand(item.id),
            _ => {}
        }
        intravisit::walk_item(self, item);
    }

    // Trait associated const defaults.
    fn visit_trait_item(&mut self, item: &'tcx hir::TraitItem) {
        match item.node {
            hir::ConstTraitItem(_, Some(_)) |
            hir::MethodTraitItem(_, Some(_)) => self.demand(item.id),
            _ => {}
        }
        intravisit::walk_trait_item(self, item);
    }

    // Impl associated const.
    fn visit_impl_item(&mut self, item: &'tcx hir::ImplItem) {
        match item.node {
            hir::ImplItemKind::Const(..) |
            hir::ImplItemKind::Method(..) => self.demand(item.id),
            _ => {}
        }
        intravisit::walk_impl_item(self, item);
    }

    // Repeat counts, i.e. [expr; constant].
    fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
        match expr.node {
            hir::ExprClosure(..) => self.demand(expr.id),
            hir::ExprRepeat(_, ref count) => self.demand(count.id),
            _ => {}
        }
        intravisit::walk_expr(self, expr);
    }

    // Array lengths, i.e. [T; constant].
    fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
        if let hir::TyArray(_, ref length) = ty.node {
            self.demand(length.id);
        }
        intravisit::walk_ty(self, ty);
    }

    // Enum variant discriminant values.
    fn visit_variant(&mut self, v: &'tcx hir::Variant,
                     g: &'tcx hir::Generics, item_id: ast::NodeId) {
        if let Some(ref expr) = v.node.disr_expr {
            self.demand(expr.id);
        }
        intravisit::walk_variant(self, v, g, item_id);
    }
}

fn closure_self_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                             closure_expr_id: ast::NodeId,
                             body_id: ast::NodeId)
                             -> Ty<'tcx> {
    let closure_ty = tcx.tables().node_id_to_type(closure_expr_id);

    // We're just hard-coding the idea that the signature will be
    // &self or &mut self and hence will have a bound region with
    // number 0, hokey.
    let region = ty::Region::ReFree(ty::FreeRegion {
        scope: tcx.region_maps.item_extent(body_id),
        bound_region: ty::BoundRegion::BrAnon(0),
    });
    let region = tcx.mk_region(region);

    match tcx.closure_kind(tcx.map.local_def_id(closure_expr_id)) {
        ty::ClosureKind::Fn =>
            tcx.mk_ref(region,
                       ty::TypeAndMut { ty: closure_ty,
                                        mutbl: hir::MutImmutable }),
        ty::ClosureKind::FnMut =>
            tcx.mk_ref(region,
                       ty::TypeAndMut { ty: closure_ty,
                                        mutbl: hir::MutMutable }),
        ty::ClosureKind::FnOnce =>
            closure_ty
    }
}