---

yaml
---
r: 174425
b: refs/heads/auto
c: a87e04c68ab5d29336427e80555fd4711d04d2ce
h: refs/heads/master
i:
  174423: 8f023d6
v: v3

Author: edwardw

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: fd488c1d3c7f330e22385a739d7271c457ada620
+refs/heads/auto: a87e04c68ab5d29336427e80555fd4711d04d2ce
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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,11 @@ 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 {

branches/auto/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};
@@ -1417,22 +1419,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
-    //      (_, _) => foo
-    // or not. 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.
-    fn all_wild_pat(pat: &ast::Pat) -> bool {
-        match pat.node {
-            ast::PatWild(ast::PatWildSingle) => true,
-            ast::PatTup(ref pats) => pats.iter().all(|p| all_wild_pat(&**p)),
-            _ => false,
+    // 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 = arms.last().map_or(false, |arm| {
-        arm.pats.len() == 1 && all_wild_pat(&**arm.pats.last().unwrap())
-    });
+    };
+    let has_default = arm_pats.iter().last().map_or(false, is_geniune_default);
 
     compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default);