Make the default branch checking more general

for match expressions to address comments.

Author: edwardw

src/librustc/middle/check_match.rs

@@ -43,7 +43,7 @@ pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
     span: DUMMY_SP
 };
 
-struct Matrix<'a>(Vec<Vec<&'a Pat>>);
+pub struct Matrix<'a>(pub Vec<Vec<&'a Pat>>);
 
 /// Pretty-printer for matrices of patterns, example:
 /// ++++++++++++++++++++++++++
@@ -120,14 +120,14 @@ pub enum Constructor {
 }
 
 #[derive(Clone, PartialEq)]
-enum Usefulness {
+pub enum Usefulness {
     Useful,
     UsefulWithWitness(Vec<P<Pat>>),
     NotUseful
 }
 
 #[derive(Copy)]
-enum WitnessPreference {
+pub enum WitnessPreference {
     ConstructWitness,
     LeaveOutWitness
 }
@@ -568,11 +568,10 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
 
 // Note: is_useful doesn't work on empty types, as the paper notes.
 // So it assumes that v is non-empty.
-fn is_useful(cx: &MatchCheckCtxt,
-             matrix: &Matrix,
-             v: &[&Pat],
-             witness: WitnessPreference)
-             -> Usefulness {
+pub fn is_useful(cx: &MatchCheckCtxt,
+                 matrix: &Matrix,
+                 v: &[&Pat],
+                 witness: WitnessPreference) -> Usefulness {
     let &Matrix(ref rows) = matrix;
     debug!("{:?}", matrix);
     if rows.len() == 0u {

src/librustc_trans/trans/_match.rs

@@ -191,6 +191,8 @@ use self::FailureHandler::*;
 use back::abi;
 use llvm::{ValueRef, BasicBlockRef};
 use middle::check_match::StaticInliner;
+use middle::check_match::Usefulness::NotUseful;
+use middle::check_match::WitnessPreference::LeaveOutWitness;
 use middle::check_match;
 use middle::const_eval;
 use middle::def::{self, DefMap};
@@ -1398,14 +1400,27 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
 
     // `compile_submatch` works one column of arm patterns a time and
     // then peels that column off. So as we progress, it may become
-    // impossible to tell whether we have a genuine default arm, i.e.
-    // `_ => foo` or not. Sometimes it is important to know that in order
-    // to decide whether moving on to the next condition or falling back
-    // to the default arm.
-    let has_default = arms.last().map_or(false, |arm| {
-        arm.pats.len() == 1
-        && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle)
-    });
+    // impossible to tell whether we have a genuine default arm or not.
+    // Computing such property upfront, however, is straightforward -
+    // if the last arm of the match expression shadows a `PatWildSingle`,
+    // then it is a genuine default arm.
+    //
+    // Sometimes it is important to know that in order to decide whether
+    // moving on to the next arm or falling back to the default one.
+    let is_geniune_default = |&: pats: &Vec<P<ast::Pat>>| {
+        let mcx = check_match::MatchCheckCtxt {
+            tcx: tcx,
+            param_env: ty::empty_parameter_environment(tcx),
+        };
+        let ps = pats.iter().map(|p| &**p).collect();
+        let matrix = check_match::Matrix(vec![ps]);
+        let candidate = [check_match::DUMMY_WILD_PAT];
+        match check_match::is_useful(&mcx, &matrix, &candidate, LeaveOutWitness) {
+            NotUseful => true,
+            _ => false
+        }
+    };
+    let has_default = arm_pats.iter().last().map_or(false, is_geniune_default);
 
     compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default);