Reuse conservative_is_uninhabited

Author: varkor

src/librustc/ty/mod.rs

@@ -529,18 +529,6 @@ impl<'tcx> TyS<'tcx> {
             _ => true,
         }
     }
-
-    // Returns true if the construction of `self` would require a value of type `!`
-    // to have been constructed. This check is conservative.
-    pub fn requires_never_value(&self) -> bool {
-        match self.sty {
-            ty::TyNever => true,
-            ty::TyRawPtr(ty_and_mut) |
-            ty::TyRef(_, ty_and_mut) => ty_and_mut.ty.requires_never_value(),
-            ty::TyTuple(comps, _) => comps.iter().any(|ty| ty.requires_never_value()),
-            _ => false
-        }
-    }
 }
 
 impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::TyS<'gcx> {

src/librustc/ty/sty.rs

@@ -1282,6 +1282,16 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    pub fn conservative_is_uninhabited(&self) -> bool {
+        // "rustc-1.0-style" uncontentious uninhabitableness check
+        match self.sty {
+            ty::TyNever => true,
+            ty::TyAdt(def, _) => def.variants.is_empty(),
+            ty::TyTuple(tys, _) => tys.iter().any(|ty| ty.conservative_is_uninhabited()),
+            _ => false
+        }
+    }
+
     pub fn is_primitive(&self) -> bool {
         match self.sty {
             TyBool | TyChar | TyInt(_) | TyUint(_) | TyFloat(_) => true,

src/librustc_mir/build/expr/into.rs

@@ -320,7 +320,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                 let ty = expr.ty;
                 let rvalue = unpack!(block = this.as_local_rvalue(block, expr));
 
-                if ty.requires_never_value() {
+                if ty.conservative_is_uninhabited() {
                     // It's impossible to have an rvalue of type `!`, so if we encounter one,
                     // we can terminate the block as unreachable immediately.
                     this.cfg.terminate(block, source_info, TerminatorKind::Unreachable);

src/librustc_mir/build/matches/mod.rs

@@ -55,7 +55,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         self.cfg.push_assign(block, dummy_source_info, &dummy_temp, dummy_access);
 
         let arms: Vec<Arm<'tcx>> = arms.into_iter().filter(|arm|
-            !arm.patterns.iter().any(|pat| pat.is_unreachable())
+            arm.patterns.iter().any(|pat| !pat.is_unreachable())
         ).collect();
 
         let mut arm_blocks = ArmBlocks {

src/librustc_mir/hair/pattern/check_match.rs

@@ -225,7 +225,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
                 let scrutinee_is_uninhabited = if self.tcx.features().exhaustive_patterns {
                     self.tcx.is_ty_uninhabited_from(module, pat_ty)
                 } else {
-                    self.conservative_is_uninhabited(pat_ty)
+                    pat_ty.conservative_is_uninhabited()
                 };
                 if !scrutinee_is_uninhabited {
                     // We know the type is inhabited, so this must be wrong
@@ -253,15 +253,6 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
         })
     }
 
-    fn conservative_is_uninhabited(&self, scrutinee_ty: Ty<'tcx>) -> bool {
-        // "rustc-1.0-style" uncontentious uninhabitableness check
-        match scrutinee_ty.sty {
-            ty::TyNever => true,
-            ty::TyAdt(def, _) => def.variants.is_empty(),
-            _ => false
-        }
-    }
-
     fn check_irrefutable(&self, pat: &'tcx Pat, origin: &str) {
         let module = self.tcx.hir.get_module_parent(pat.id);
         MatchCheckCtxt::create_and_enter(self.tcx, module, |ref mut cx| {

src/librustc_mir/hair/pattern/mod.rs

@@ -311,12 +311,12 @@ impl<'a, 'tcx> Pattern<'tcx> {
     // Returns true if the pattern cannot bind, as it would require a value of type `!` to have
     // been constructed. This check is conservative.
     pub fn is_unreachable(&self) -> bool {
-        if self.ty.requires_never_value() {
+        if self.ty.conservative_is_uninhabited() {
             return true;
         }
         match *self.kind {
             PatternKind::Binding { ty, ref subpattern, .. } => {
-                if ty.requires_never_value() {
+                if ty.conservative_is_uninhabited() {
                     return true;
                 }
                 if let &Some(ref subpattern) = subpattern {

src/test/mir-opt/never_type_unreachable.rs

@@ -55,6 +55,7 @@ pub fn main() { }
 
 // START rustc.never_ref.SimplifyCfg-initial.after.mir
 // bb0: {
+//     ...
 //     unreachable;
 // }
 // END rustc.never_ref.SimplifyCfg-initial.after.mir