Fix diverging closures

Author: sanxiyn

src/librustc/middle/traits/util.rs

@@ -506,7 +506,7 @@ pub fn closure_trait_ref_and_return_type<'tcx>(
         def_id: fn_trait_def_id,
         substs: tcx.mk_substs(trait_substs),
     });
-    ty::Binder((trait_ref, sig.0.output.unwrap()))
+    ty::Binder((trait_ref, sig.0.output.unwrap_or(ty::mk_nil(tcx))))
 }
 
 impl<'tcx,O:Repr<'tcx>> Repr<'tcx> for super::Obligation<'tcx, O> {

src/librustc/middle/ty.rs

@@ -1092,6 +1092,13 @@ impl<'tcx> FnOutput<'tcx> {
             ty::FnDiverging => unreachable!()
         }
     }
+
+    pub fn unwrap_or(self, def: Ty<'tcx>) -> Ty<'tcx> {
+        match self {
+            ty::FnConverging(t) => t,
+            ty::FnDiverging => def
+        }
+    }
 }
 
 pub type PolyFnOutput<'tcx> = Binder<FnOutput<'tcx>>;

src/librustc_typeck/check/callee.rs

@@ -387,10 +387,11 @@ impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> {
                     demand::eqtype(fcx, self.call_expr.span, self_arg_ty, method_arg_ty);
                 }
 
+                let nilty = ty::mk_nil(fcx.tcx());
                 demand::eqtype(fcx,
                                self.call_expr.span,
-                               method_sig.output.unwrap(),
-                               self.fn_sig.output.unwrap());
+                               method_sig.output.unwrap_or(nilty),
+                               self.fn_sig.output.unwrap_or(nilty));
 
                 write_overloaded_call_method_map(fcx, self.call_expr, method_callee);
             }

src/test/run-fail/diverging-closure.rs

@@ -0,0 +1,18 @@
+// 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.
+
+// error-pattern:oops
+
+fn main() {
+    let func = || -> ! {
+        panic!("oops");
+    };
+    func();
+}