mir: factor out the parts of MIR building which are not fn-specific.

Author: eddyb

src/librustc_mir/build/mod.rs

@@ -10,12 +10,13 @@
 
 use hair::cx::Cx;
 use rustc::middle::region::{CodeExtent, CodeExtentData};
-use rustc::ty::{self, FnOutput, Ty};
+use rustc::ty::{self, Ty};
 use rustc::mir::repr::*;
 use rustc_data_structures::fnv::FnvHashMap;
 use rustc::hir;
 use rustc::hir::pat_util::pat_is_binding;
 use std::ops::{Index, IndexMut};
+use syntax::abi::Abi;
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::parse::token::keywords;
@@ -159,74 +160,51 @@ macro_rules! unpack {
 ///////////////////////////////////////////////////////////////////////////
 /// the main entry point for building MIR for a function
 
-pub fn construct<'a,'tcx>(hir: Cx<'a,'tcx>,
-                          span: Span,
-                          fn_id: ast::NodeId,
-                          body_id: ast::NodeId,
-                          implicit_arguments: Vec<Ty<'tcx>>,
-                          explicit_arguments: Vec<(Ty<'tcx>, &'tcx hir::Pat)>,
-                          return_ty: FnOutput<'tcx>,
-                          ast_block: &'tcx hir::Block)
-                          -> (Mir<'tcx>, ScopeAuxiliaryVec) {
+pub fn construct_fn<'a, 'tcx, A>(hir: Cx<'a,'tcx>,
+                                 fn_id: ast::NodeId,
+                                 arguments: A,
+                                 return_ty: ty::FnOutput<'tcx>,
+                                 ast_block: &'tcx hir::Block)
+                                 -> (Mir<'tcx>, ScopeAuxiliaryVec)
+    where A: Iterator<Item=(Ty<'tcx>, Option<&'tcx hir::Pat>)>
+{
     let tcx = hir.tcx();
-    let cfg = CFG { basic_blocks: vec![] };
-
-    let mut builder = Builder {
-        hir: hir,
-        cfg: cfg,
-        fn_span: span,
-        scopes: vec![],
-        scope_datas: vec![],
-        scope_auxiliary: ScopeAuxiliaryVec { vec: vec![] },
-        loop_scopes: vec![],
-        temp_decls: vec![],
-        var_decls: vec![],
-        var_indices: FnvHashMap(),
-        unit_temp: None,
-        cached_resume_block: None,
-        cached_return_block: None
-    };
-
-    assert_eq!(builder.cfg.start_new_block(), START_BLOCK);
+    let span = tcx.map.span(fn_id);
+    let mut builder = Builder::new(hir, span);
 
-    let mut arg_decls = None; // assigned to `Some` in closures below
+    let body_id = ast_block.id;
     let call_site_extent =
         tcx.region_maps.lookup_code_extent(
             CodeExtentData::CallSiteScope { fn_id: fn_id, body_id: body_id });
-    let _ = builder.in_scope(call_site_extent, START_BLOCK, |builder, call_site_scope_id| {
-        let mut block = START_BLOCK;
-        let arg_extent =
-            tcx.region_maps.lookup_code_extent(
-                CodeExtentData::ParameterScope { fn_id: fn_id, body_id: body_id });
-        unpack!(block = builder.in_scope(arg_extent, block, |builder, arg_scope_id| {
-            arg_decls = Some(unpack!(block = builder.args_and_body(block,
-                                                                   return_ty,
-                                                                   implicit_arguments,
-                                                                   explicit_arguments,
-                                                                   arg_scope_id,
-                                                                   ast_block)));
-            block.unit()
+    let arg_extent =
+        tcx.region_maps.lookup_code_extent(
+            CodeExtentData::ParameterScope { fn_id: fn_id, body_id: body_id });
+    let mut block = START_BLOCK;
+    let mut arg_decls = unpack!(block = builder.in_scope(call_site_extent, block,
+                                                         |builder, call_site_scope_id| {
+        let arg_decls = unpack!(block = builder.in_scope(arg_extent, block,
+                                                         |builder, arg_scope_id| {
+            builder.args_and_body(block, return_ty, arguments, arg_scope_id, ast_block)
         }));
 
         let return_block = builder.return_block();
         builder.cfg.terminate(block, call_site_scope_id, span,
                               TerminatorKind::Goto { target: return_block });
         builder.cfg.terminate(return_block, call_site_scope_id, span,
                               TerminatorKind::Return);
-        return_block.unit()
-    });
-
-    assert!(
-        builder.cfg.basic_blocks
-                   .iter()
-                   .enumerate()
-                   .all(|(index, block)| {
-                       if block.terminator.is_none() {
-                           bug!("no terminator on block {:?} in fn {:?}",
-                                index, fn_id)
-                       }
-                       true
-                   }));
+        return_block.and(arg_decls)
+    }));
+    assert_eq!(block, builder.return_block());
+
+    match tcx.node_id_to_type(fn_id).sty {
+        ty::TyFnDef(_, _, f) if f.abi == Abi::RustCall => {
+            // RustCall pseudo-ABI untuples the last argument.
+            if let Some(arg_decl) = arg_decls.last_mut() {
+                arg_decl.spread = true;
+            }
+        }
+        _ => {}
+    }
 
     // Gather the upvars of a closure, if any.
     let upvar_decls: Vec<_> = tcx.with_freevars(fn_id, |freevars| {
@@ -251,72 +229,98 @@ pub fn construct<'a,'tcx>(hir: Cx<'a,'tcx>,
         }).collect()
     });
 
-    (
-        Mir {
-            basic_blocks: builder.cfg.basic_blocks,
-            scopes: builder.scope_datas,
-            var_decls: builder.var_decls,
-            arg_decls: arg_decls.take().expect("args never built?"),
-            temp_decls: builder.temp_decls,
-            upvar_decls: upvar_decls,
-            return_ty: return_ty,
-            span: span
-        },
-        builder.scope_auxiliary,
-    )
+    builder.finish(upvar_decls, arg_decls, return_ty)
 }
 
 impl<'a,'tcx> Builder<'a,'tcx> {
-    fn args_and_body(&mut self,
-                     mut block: BasicBlock,
-                     return_ty: FnOutput<'tcx>,
-                     implicit_arguments: Vec<Ty<'tcx>>,
-                     explicit_arguments: Vec<(Ty<'tcx>, &'tcx hir::Pat)>,
-                     argument_scope_id: ScopeId,
-                     ast_block: &'tcx hir::Block)
-                     -> BlockAnd<Vec<ArgDecl<'tcx>>>
+    fn new(hir: Cx<'a, 'tcx>, span: Span) -> Builder<'a, 'tcx> {
+        let mut builder = Builder {
+            hir: hir,
+            cfg: CFG { basic_blocks: vec![] },
+            fn_span: span,
+            scopes: vec![],
+            scope_datas: vec![],
+            scope_auxiliary: ScopeAuxiliaryVec { vec: vec![] },
+            loop_scopes: vec![],
+            temp_decls: vec![],
+            var_decls: vec![],
+            var_indices: FnvHashMap(),
+            unit_temp: None,
+            cached_resume_block: None,
+            cached_return_block: None
+        };
+
+        assert_eq!(builder.cfg.start_new_block(), START_BLOCK);
+
+        builder
+    }
+
+    fn finish(self,
+              upvar_decls: Vec<UpvarDecl>,
+              arg_decls: Vec<ArgDecl<'tcx>>,
+              return_ty: ty::FnOutput<'tcx>)
+              -> (Mir<'tcx>, ScopeAuxiliaryVec) {
+        for (index, block) in self.cfg.basic_blocks.iter().enumerate() {
+            if block.terminator.is_none() {
+                span_bug!(self.fn_span, "no terminator on block {:?}", index);
+            }
+        }
+
+        (Mir {
+            basic_blocks: self.cfg.basic_blocks,
+            scopes: self.scope_datas,
+            var_decls: self.var_decls,
+            arg_decls: arg_decls,
+            temp_decls: self.temp_decls,
+            upvar_decls: upvar_decls,
+            return_ty: return_ty,
+            span: self.fn_span
+        }, self.scope_auxiliary)
+    }
+
+    fn args_and_body<A>(&mut self,
+                        mut block: BasicBlock,
+                        return_ty: ty::FnOutput<'tcx>,
+                        arguments: A,
+                        argument_scope_id: ScopeId,
+                        ast_block: &'tcx hir::Block)
+                        -> BlockAnd<Vec<ArgDecl<'tcx>>>
+        where A: Iterator<Item=(Ty<'tcx>, Option<&'tcx hir::Pat>)>
     {
         // to start, translate the argument patterns and collect the argument types.
-        let implicits = implicit_arguments.into_iter().map(|ty| (ty, None));
-        let explicits = explicit_arguments.into_iter().map(|(ty, pat)| (ty, Some(pat)));
-            let arg_decls =
-            implicits
-            .chain(explicits)
-            .enumerate()
-            .map(|(index, (ty, pattern))| {
-                let lvalue = Lvalue::Arg(index as u32);
-                if let Some(pattern) = pattern {
-                    let pattern = self.hir.irrefutable_pat(pattern);
-                    unpack!(block = self.lvalue_into_pattern(block,
-                                                             argument_scope_id,
-                                                             pattern,
-                                                             &lvalue));
-                }
+        let arg_decls = arguments.enumerate().map(|(index, (ty, pattern))| {
+            let lvalue = Lvalue::Arg(index as u32);
+            if let Some(pattern) = pattern {
+                let pattern = self.hir.irrefutable_pat(pattern);
+                unpack!(block = self.lvalue_into_pattern(block,
+                                                         argument_scope_id,
+                                                         pattern,
+                                                         &lvalue));
+            }
 
-                // Make sure we drop (parts of) the argument even when not matched on.
-                let argument_extent = self.scope_auxiliary[argument_scope_id].extent;
-                self.schedule_drop(pattern.as_ref().map_or(ast_block.span, |pat| pat.span),
-                                   argument_extent, &lvalue, ty);
-
-                let mut name = keywords::Invalid.name();
-                if let Some(pat) = pattern {
-                    if let hir::PatKind::Ident(_, ref ident, _) = pat.node {
-                        if pat_is_binding(&self.hir.tcx().def_map.borrow(), pat) {
-                            name = ident.node.name;
-                        }
+            // Make sure we drop (parts of) the argument even when not matched on.
+            let argument_extent = self.scope_auxiliary[argument_scope_id].extent;
+            self.schedule_drop(pattern.as_ref().map_or(ast_block.span, |pat| pat.span),
+                               argument_extent, &lvalue, ty);
+
+            let mut name = keywords::Invalid.name();
+            if let Some(pat) = pattern {
+                if let hir::PatKind::Ident(_, ref ident, _) = pat.node {
+                    if pat_is_binding(&self.hir.tcx().def_map.borrow(), pat) {
+                        name = ident.node.name;
                     }
                 }
+            }
 
-                ArgDecl {
-                    ty: ty,
-                    spread: false,
-                    debug_name: name
-                }
-            })
-            .collect();
+            ArgDecl {
+                ty: ty,
+                spread: false,
+                debug_name: name
+            }
+        }).collect();
 
         // FIXME(#32959): temporary hack for the issue at hand
-        let return_is_unit = if let FnOutput::FnConverging(t) = return_ty {
+        let return_is_unit = if let ty::FnConverging(t) = return_ty {
             t.is_nil()
         } else {
             false