Merge the ExprFnBlock and ExprUnboxedClosure into one ExprClosure with an optional unboxed closure kind.

Author: nikomatsakis

src/librustc/middle/borrowck/mod.rs

@@ -288,9 +288,12 @@ pub fn closure_to_block(closure_id: ast::NodeId,
     match tcx.map.get(closure_id) {
         ast_map::NodeExpr(expr) => match expr.node {
             ast::ExprProc(_, ref block) |
-            ast::ExprFnBlock(_, _, ref block) |
-            ast::ExprUnboxedFn(_, _, _, ref block) => { block.id }
-            _ => panic!("encountered non-closure id: {}", closure_id)
+            ast::ExprClosure(_, _, _, ref block) => {
+                block.id
+            }
+            _ => {
+                panic!("encountered non-closure id: {}", closure_id)
+            }
         },
         _ => panic!("encountered non-expr id: {}", closure_id)
     }

src/librustc/middle/cfg/construct.rs

@@ -496,9 +496,8 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             }
 
             ast::ExprMac(..) |
-            ast::ExprFnBlock(..) |
+            ast::ExprClosure(..) |
             ast::ExprProc(..) |
-            ast::ExprUnboxedFn(..) |
             ast::ExprLit(..) |
             ast::ExprPath(..) => {
                 self.straightline(expr, pred, None::<ast::Expr>.iter())

src/librustc/middle/check_loop.rs

@@ -48,9 +48,8 @@ impl<'a, 'v> Visitor<'v> for CheckLoopVisitor<'a> {
                 self.visit_expr(&**e);
                 self.with_context(Loop, |v| v.visit_block(&**b));
             }
-            ast::ExprFnBlock(_, _, ref b) |
-            ast::ExprProc(_, ref b) |
-            ast::ExprUnboxedFn(_, _, _, ref b) => {
+            ast::ExprClosure(_, _, _, ref b) |
+            ast::ExprProc(_, ref b) => {
                 self.with_context(Closure, |v| v.visit_block(&**b));
             }
             ast::ExprBreak(_) => self.require_loop("break", e.span),

src/librustc/middle/expr_use_visitor.rs

@@ -496,8 +496,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                 self.consume_expr(&**count);
             }
 
-            ast::ExprFnBlock(..) |
-            ast::ExprUnboxedFn(..) |
+            ast::ExprClosure(..) |
             ast::ExprProc(..) => {
                 self.walk_captures(expr)
             }

src/librustc/middle/liveness.rs

@@ -458,7 +458,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
         }
         visit::walk_expr(ir, expr);
       }
-      ast::ExprFnBlock(..) | ast::ExprProc(..) | ast::ExprUnboxedFn(..) => {
+      ast::ExprClosure(..) | ast::ExprProc(..) => {
         // Interesting control flow (for loops can contain labeled
         // breaks or continues)
         ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
@@ -975,10 +975,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
               self.propagate_through_expr(&**e, succ)
           }
 
-          ast::ExprFnBlock(_, _, ref blk) |
-          ast::ExprProc(_, ref blk) |
-          ast::ExprUnboxedFn(_, _, _, ref blk) => {
-              debug!("{} is an ExprFnBlock, ExprProc, or ExprUnboxedFn",
+          ast::ExprClosure(_, _, _, ref blk) |
+          ast::ExprProc(_, ref blk) => {
+              debug!("{} is an ExprClosure or ExprProc",
                      expr_to_string(expr));
 
               /*
@@ -1495,7 +1494,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
       ast::ExprBreak(..) | ast::ExprAgain(..) | ast::ExprLit(_) |
       ast::ExprBlock(..) | ast::ExprMac(..) | ast::ExprAddrOf(..) |
       ast::ExprStruct(..) | ast::ExprRepeat(..) | ast::ExprParen(..) |
-      ast::ExprFnBlock(..) | ast::ExprProc(..) | ast::ExprUnboxedFn(..) |
+      ast::ExprClosure(..) | ast::ExprProc(..) |
       ast::ExprPath(..) | ast::ExprBox(..) | ast::ExprSlice(..) => {
         visit::walk_expr(this, expr);
       }

src/librustc/middle/mem_categorization.rs

@@ -520,8 +520,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
 
           ast::ExprAddrOf(..) | ast::ExprCall(..) |
           ast::ExprAssign(..) | ast::ExprAssignOp(..) |
-          ast::ExprFnBlock(..) | ast::ExprProc(..) |
-          ast::ExprUnboxedFn(..) | ast::ExprRet(..) |
+          ast::ExprClosure(..) | ast::ExprProc(..) |
+          ast::ExprRet(..) |
           ast::ExprUnary(..) | ast::ExprSlice(..) |
           ast::ExprMethodCall(..) | ast::ExprCast(..) |
           ast::ExprVec(..) | ast::ExprTup(..) | ast::ExprIf(..) |
@@ -693,9 +693,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                 };
 
                 match fn_expr.node {
-                    ast::ExprFnBlock(_, _, ref body) |
                     ast::ExprProc(_, ref body) |
-                    ast::ExprUnboxedFn(_, _, _, ref body) => body.id,
+                    ast::ExprClosure(_, _, _, ref body) => body.id,
                     _ => unreachable!()
                 }
             };

src/librustc/middle/resolve.rs

@@ -50,8 +50,8 @@ use util::nodemap::{NodeMap, NodeSet, DefIdSet, FnvHashMap};
 
 use syntax::ast::{Arm, BindByRef, BindByValue, BindingMode, Block, Crate, CrateNum};
 use syntax::ast::{DeclItem, DefId, Expr, ExprAgain, ExprBreak, ExprField};
-use syntax::ast::{ExprFnBlock, ExprForLoop, ExprLoop, ExprWhile, ExprMethodCall};
-use syntax::ast::{ExprPath, ExprProc, ExprStruct, ExprUnboxedFn, FnDecl};
+use syntax::ast::{ExprClosure, ExprForLoop, ExprLoop, ExprWhile, ExprMethodCall};
+use syntax::ast::{ExprPath, ExprProc, ExprStruct, FnDecl};
 use syntax::ast::{ForeignItem, ForeignItemFn, ForeignItemStatic, Generics};
 use syntax::ast::{Ident, ImplItem, Item, ItemEnum, ItemFn, ItemForeignMod};
 use syntax::ast::{ItemImpl, ItemMac, ItemMod, ItemStatic, ItemStruct};
@@ -5903,24 +5903,19 @@ impl<'a> Resolver<'a> {
                 visit::walk_expr(self, expr);
             }
 
-            ExprFnBlock(capture_clause, ref fn_decl, ref block) => {
+            ExprClosure(capture_clause, _, ref fn_decl, ref block) => {
                 self.capture_mode_map.insert(expr.id, capture_clause);
                 self.resolve_function(ClosureRibKind(expr.id, ast::DUMMY_NODE_ID),
                                       Some(&**fn_decl), NoTypeParameters,
                                       &**block);
             }
+
             ExprProc(ref fn_decl, ref block) => {
                 self.capture_mode_map.insert(expr.id, ast::CaptureByValue);
                 self.resolve_function(ClosureRibKind(expr.id, block.id),
                                       Some(&**fn_decl), NoTypeParameters,
                                       &**block);
             }
-            ExprUnboxedFn(capture_clause, _, ref fn_decl, ref block) => {
-                self.capture_mode_map.insert(expr.id, capture_clause);
-                self.resolve_function(ClosureRibKind(expr.id, block.id),
-                                      Some(&**fn_decl), NoTypeParameters,
-                                      &**block);
-            }
 
             ExprStruct(ref path, _, _) => {
                 // Resolve the path to the structure it goes to. We don't

src/librustc/middle/ty.rs

@@ -3922,9 +3922,8 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
         ast::ExprTup(..) |
         ast::ExprIf(..) |
         ast::ExprMatch(..) |
-        ast::ExprFnBlock(..) |
+        ast::ExprClosure(..) |
         ast::ExprProc(..) |
-        ast::ExprUnboxedFn(..) |
         ast::ExprBlock(..) |
         ast::ExprRepeat(..) |
         ast::ExprVec(..) => {

src/librustc/middle/typeck/astconv.rs

@@ -1047,7 +1047,7 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
             }
             ast::TyInfer => {
                 // TyInfer also appears as the type of arguments or return
-                // values in a ExprFnBlock, ExprProc, or ExprUnboxedFn, or as
+                // values in a ExprClosure or ExprProc, or as
                 // the type of local variables. Both of these cases are
                 // handled specially and will not descend into this routine.
                 this.ty_infer(ast_ty.span)

src/librustc/middle/typeck/check/closure.rs

@@ -26,12 +26,38 @@ use syntax::ast;
 use syntax::ast_util;
 use util::ppaux::Repr;
 
-pub fn check_unboxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
-                                      expr: &ast::Expr,
-                                      kind: ast::UnboxedClosureKind,
-                                      decl: &ast::FnDecl,
-                                      body: &ast::Block,
-                                      expected: Expectation<'tcx>) {
+pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
+                                   expr: &ast::Expr,
+                                   opt_kind: Option<ast::UnboxedClosureKind>,
+                                   decl: &ast::FnDecl,
+                                   body: &ast::Block,
+                                   expected: Expectation<'tcx>) {
+    match opt_kind {
+        None => { // old-school boxed closure
+            let region = astconv::opt_ast_region_to_region(fcx,
+                                                           fcx.infcx(),
+                                                           expr.span,
+                                                           &None);
+            check_boxed_closure(fcx,
+                                expr,
+                                ty::RegionTraitStore(region, ast::MutMutable),
+                                decl,
+                                body,
+                                expected);
+        }
+
+        Some(kind) => {
+            check_unboxed_closure(fcx, expr, kind, decl, body, expected)
+        }
+    }
+}
+
+fn check_unboxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
+                                  expr: &ast::Expr,
+                                  kind: ast::UnboxedClosureKind,
+                                  decl: &ast::FnDecl,
+                                  body: &ast::Block,
+                                  expected: Expectation<'tcx>) {
     let expr_def_id = ast_util::local_def(expr.id);
 
     let expected_sig_and_kind = match expected.resolve(fcx) {
@@ -215,12 +241,12 @@ fn deduce_unboxed_closure_expectations_from_obligations<'a,'tcx>(
 }
 
 
-pub fn check_expr_fn<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
-                              expr: &ast::Expr,
-                              store: ty::TraitStore,
-                              decl: &ast::FnDecl,
-                              body: &ast::Block,
-                              expected: Expectation<'tcx>) {
+pub fn check_boxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
+                                    expr: &ast::Expr,
+                                    store: ty::TraitStore,
+                                    decl: &ast::FnDecl,
+                                    body: &ast::Block,
+                                    expected: Expectation<'tcx>) {
     let tcx = fcx.ccx.tcx;
 
     // Find the expected input/output types (if any). Substitute