Remove obsolete divergence related stuff

Replace FnOutput with Ty
Replace FnConverging(ty) with ty
Purge FnDiverging, FunctionRetTy::NoReturn and FunctionRetTy::None

3 files changed, 15 insertions, 28 deletions

diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
index eb0d8697f15..aaa20405b8d 100644
--- a/src/librustc_mir/transform/promote_consts.rs
+++ b/src/librustc_mir/transform/promote_consts.rs
@@ -25,7 +25,7 @@
 use rustc::mir::repr::*;
 use rustc::mir::visit::{LvalueContext, MutVisitor, Visitor};
 use rustc::mir::traversal::ReversePostorder;
-use rustc::ty::{self, TyCtxt};
+use rustc::ty::TyCtxt;
 use syntax_pos::Span;
 
 use build::Location;
@@ -299,7 +299,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
         let span = self.promoted.span;
         let new_operand = Operand::Constant(Constant {
             span: span,
-            ty: self.promoted.return_ty.unwrap(),
+            ty: self.promoted.return_ty,
             literal: Literal::Promoted {
                 index: Promoted::new(self.source.promoted.len())
             }
@@ -389,7 +389,7 @@ pub fn promote_candidates<'a, 'tcx>(mir: &mut Mir<'tcx>,
                     parent_scope: None
                 }).into_iter().collect(),
                 IndexVec::new(),
-                ty::FnConverging(ty),
+                ty,
                 IndexVec::new(),
                 IndexVec::new(),
                 IndexVec::new(),
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
index 7ebc72bcc5f..57c0f66448d 100644
--- a/src/librustc_mir/transform/qualify_consts.rs
+++ b/src/librustc_mir/transform/qualify_consts.rs
@@ -416,7 +416,7 @@ impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
             }
         }
 
-        let return_ty = mir.return_ty.unwrap();
+        let return_ty = mir.return_ty;
         self.qualif = self.return_qualif.unwrap_or(Qualif::NOT_CONST);
 
         match self.mode {
@@ -991,7 +991,7 @@ impl<'tcx> MirMapPass<'tcx> for QualifyAndPromoteConstants {
 
             // Statics must be Sync.
             if mode == Mode::Static {
-                let ty = mir.return_ty.unwrap();
+                let ty = mir.return_ty;
                 tcx.infer_ctxt(None, None, Reveal::NotSpecializable).enter(|infcx| {
                     let cause = traits::ObligationCause::new(mir.span, id, traits::SharedStatic);
                     let mut fulfillment_cx = traits::FulfillmentContext::new();
diff --git a/src/librustc_mir/transform/type_check.rs b/src/librustc_mir/transform/type_check.rs
index 53329a85036..501b69bb12a 100644
--- a/src/librustc_mir/transform/type_check.rs
+++ b/src/librustc_mir/transform/type_check.rs
@@ -85,9 +85,7 @@ impl<'a, 'b, 'gcx, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'gcx, 'tcx> {
     }
 
     fn visit_mir(&mut self, mir: &Mir<'tcx>) {
-        if let ty::FnConverging(t) = mir.return_ty {
-            self.sanitize_type(&"return type", t);
-        }
+        self.sanitize_type(&"return type", mir.return_ty);
         for var_decl in &mir.var_decls {
             self.sanitize_type(var_decl, var_decl.ty);
         }
@@ -135,14 +133,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeVerifier<'a, 'b, 'gcx, 'tcx> {
             Lvalue::Static(def_id) =>
                 LvalueTy::Ty { ty: self.tcx().lookup_item_type(def_id).ty },
             Lvalue::ReturnPointer => {
-                if let ty::FnConverging(return_ty) = self.mir.return_ty {
-                    LvalueTy::Ty { ty: return_ty }
-                } else {
-                    LvalueTy::Ty {
-                        ty: span_mirbug_and_err!(
-                            self, lvalue, "return in diverging function")
-                    }
-                }
+                LvalueTy::Ty { ty: self.mir.return_ty }
             }
             Lvalue::Projection(ref proj) => {
                 let base_ty = self.sanitize_lvalue(&proj.base);
@@ -491,24 +482,20 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                        sig: &ty::FnSig<'tcx>,
                        destination: &Option<(Lvalue<'tcx>, BasicBlock)>) {
         let tcx = self.tcx();
-        match (destination, sig.output) {
-            (&Some(..), ty::FnDiverging) => {
-                span_mirbug!(self, term, "call to diverging function {:?} with dest", sig);
-            }
-            (&Some((ref dest, _)), ty::FnConverging(ty)) => {
+        match *destination {
+            Some((ref dest, _)) => {
                 let dest_ty = dest.ty(mir, tcx).to_ty(tcx);
-                if let Err(terr) = self.sub_types(self.last_span, ty, dest_ty) {
+                if let Err(terr) = self.sub_types(self.last_span, sig.output, dest_ty) {
                     span_mirbug!(self, term,
                                  "call dest mismatch ({:?} <- {:?}): {:?}",
-                                 dest_ty, ty, terr);
+                                 dest_ty, sig.output, terr);
                 }
-            }
-            (&None, ty::FnDiverging) => {}
-            (&None, ty::FnConverging(ref ty)) => {
-                if !ty.is_empty(tcx) {
+            },
+            None => {
+                if !sig.output.is_empty(tcx) {
                     span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);
                 }
-            }
+            },
         }
     }