---

yaml
---
r: 128447
b: refs/heads/auto
c: d7916f8
h: refs/heads/master
i:
  128445: 70eac4f
  128443: 3659240
  128439: d33d1af
  128431: 16e101d
  128415: 77c24d5
  128383: 80d28ac
v: v3

Author: klutzy

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 1824973a139443b15e2c093b3e316169f2792cb3
+refs/heads/auto: d7916f8d4416e739aec3226adb0df1077e15a80a
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libregex/lib.rs

@@ -395,8 +395,7 @@ mod parse;
 mod re;
 mod vm;
 
-// FIXME(#13725) windows needs fixing.
-#[cfg(test, not(windows))]
+#[cfg(test)]
 mod test;
 
 /// The `native` module exists to support the `regex!` macro. Do not use.

branches/auto/src/librustc/diagnostics.rs

@@ -139,6 +139,7 @@ register_diagnostics!(
     E0120,
     E0121,
     E0122,
+    E0123,
     E0124,
     E0125,
     E0126,
@@ -172,6 +173,5 @@ register_diagnostics!(
     E0154,
     E0155,
     E0156,
-    E0157,
-    E0158
+    E0157
 )

branches/auto/src/librustc/middle/check_match.rs

@@ -23,7 +23,7 @@ use std::gc::{Gc, GC};
 use std::iter::AdditiveIterator;
 use std::iter::range_inclusive;
 use syntax::ast::*;
-use syntax::ast_util::walk_pat;
+use syntax::ast_util::{is_unguarded, walk_pat};
 use syntax::codemap::{Span, Spanned, DUMMY_SP};
 use syntax::fold::{Folder, noop_fold_pat};
 use syntax::print::pprust::pat_to_string;
@@ -159,31 +159,13 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
                 }
             }
 
-            let mut static_inliner = StaticInliner::new(cx.tcx);
-            let inlined_arms = arms
-                .iter()
-                .map(|arm| Arm {
-                    pats: arm.pats.iter().map(|pat| {
-                        static_inliner.fold_pat(*pat)
-                    }).collect(),
-                    ..arm.clone()
-                })
-                .collect::<Vec<Arm>>();
-
-            if static_inliner.failed {
-                return;
-            }
-
-            // Third, check if there are any references to NaN that we should warn about.
-            check_for_static_nan(cx, inlined_arms.as_slice());
-
-            // Fourth, check for unreachable arms.
-            check_arms(cx, inlined_arms.as_slice());
+            // Third, check for unreachable arms.
+            check_arms(cx, arms.as_slice());
 
             // Finally, check if the whole match expression is exhaustive.
             // Check for empty enum, because is_useful only works on inhabited types.
             let pat_ty = node_id_to_type(cx.tcx, scrut.id);
-            if inlined_arms.is_empty() {
+            if arms.is_empty() {
                 if !type_is_empty(cx.tcx, pat_ty) {
                     // We know the type is inhabited, so this must be wrong
                     span_err!(cx.tcx.sess, ex.span, E0002,
@@ -195,16 +177,19 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
                 return;
             }
 
-            let matrix: Matrix = inlined_arms
-                .move_iter()
-                .filter(|arm| arm.guard.is_none())
-                .flat_map(|arm| arm.pats.move_iter())
-                .map(|pat| vec![pat])
+            let mut static_inliner = StaticInliner { tcx: cx.tcx };
+            let matrix: Matrix = arms
+                .iter()
+                .filter(|&arm| is_unguarded(arm))
+                .flat_map(|arm| arm.pats.iter())
+                .map(|pat| vec![static_inliner.fold_pat(*pat)])
                 .collect();
             check_exhaustive(cx, ex.span, &matrix);
         },
         ExprForLoop(ref pat, _, _, _) => {
-            let mut static_inliner = StaticInliner::new(cx.tcx);
+            let mut static_inliner = StaticInliner {
+                tcx: cx.tcx
+            };
             match is_refutable(cx, static_inliner.fold_pat(*pat)) {
                 Some(uncovered_pat) => {
                     cx.tcx.sess.span_err(
@@ -231,31 +216,28 @@ fn is_expr_const_nan(tcx: &ty::ctxt, expr: &Expr) -> bool {
     }
 }
 
-// Check that we do not match against a static NaN (#6804)
-fn check_for_static_nan(cx: &MatchCheckCtxt, arms: &[Arm]) {
+// Check for unreachable patterns
+fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) {
+    let mut seen = Matrix(vec!());
+    let mut static_inliner = StaticInliner { tcx: cx.tcx };
     for arm in arms.iter() {
-        for &pat in arm.pats.iter() {
-            walk_pat(&*pat, |p| {
+        for pat in arm.pats.iter() {
+            let inlined = static_inliner.fold_pat(*pat);
+
+            // Check that we do not match against a static NaN (#6804)
+            walk_pat(&*inlined, |p| {
                 match p.node {
                     PatLit(expr) if is_expr_const_nan(cx.tcx, &*expr) => {
-                        span_warn!(cx.tcx.sess, p.span, E0003,
+                        span_warn!(cx.tcx.sess, pat.span, E0003,
                             "unmatchable NaN in pattern, \
                              use the is_nan method in a guard instead");
                     }
                     _ => ()
                 }
                 true
             });
-        }
-    }
-}
 
-// Check for unreachable patterns
-fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) {
-    let mut seen = Matrix(vec!());
-    for arm in arms.iter() {
-        for &pat in arm.pats.iter() {
-            let v = vec![pat];
+            let v = vec![inlined];
             match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) {
                 NotUseful => span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern"),
                 Useful => (),
@@ -311,17 +293,7 @@ fn const_val_to_expr(value: &const_val) -> Gc<Expr> {
 }
 
 pub struct StaticInliner<'a> {
-    pub tcx: &'a ty::ctxt,
-    pub failed: bool
-}
-
-impl<'a> StaticInliner<'a> {
-    pub fn new<'a>(tcx: &'a ty::ctxt) -> StaticInliner<'a> {
-        StaticInliner {
-            tcx: tcx,
-            failed: false
-        }
-    }
+    pub tcx: &'a ty::ctxt
 }
 
 impl<'a> Folder for StaticInliner<'a> {
@@ -330,17 +302,9 @@ impl<'a> Folder for StaticInliner<'a> {
             PatIdent(..) | PatEnum(..) => {
                 let def = self.tcx.def_map.borrow().find_copy(&pat.id);
                 match def {
-                    Some(DefStatic(did, _)) => match lookup_const_by_id(self.tcx, did) {
-                        Some(const_expr) => box (GC) Pat {
-                            span: pat.span,
-                            ..(*const_expr_to_pat(self.tcx, const_expr)).clone()
-                        },
-                        None => {
-                            self.failed = true;
-                            span_err!(self.tcx.sess, pat.span, E0158,
-                                "extern statics cannot be referenced in patterns");
-                            pat
-                        }
+                    Some(DefStatic(did, _)) => {
+                        let const_expr = lookup_const_by_id(self.tcx, did).unwrap();
+                        const_expr_to_pat(self.tcx, const_expr)
                     },
                     _ => noop_fold_pat(pat, self)
                 }
@@ -849,7 +813,7 @@ fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
         LocalFor => "`for` loop"
     };
 
-    let mut static_inliner = StaticInliner::new(cx.tcx);
+    let mut static_inliner = StaticInliner { tcx: cx.tcx };
     match is_refutable(cx, static_inliner.fold_pat(loc.pat)) {
         Some(pat) => {
             span_err!(cx.tcx.sess, loc.pat.span, E0005,

branches/auto/src/librustc/middle/trans/_match.rs

@@ -1422,7 +1422,7 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>,
         bindings_map: create_bindings_map(bcx, *arm.pats.get(0), discr_expr, &*arm.body)
     }).collect();
 
-    let mut static_inliner = StaticInliner::new(scope_cx.tcx());
+    let mut static_inliner = StaticInliner { tcx: scope_cx.tcx() };
     let mut matches = Vec::new();
     for arm_data in arm_datas.iter() {
         matches.extend(arm_data.arm.pats.iter().map(|&p| Match {

branches/auto/src/libsyntax/ast_util.rs

@@ -209,6 +209,21 @@ pub fn name_to_dummy_lifetime(name: Name) -> Lifetime {
                name: name }
 }
 
+pub fn is_unguarded(a: &Arm) -> bool {
+    match a.guard {
+      None => true,
+      _    => false
+    }
+}
+
+pub fn unguarded_pat(a: &Arm) -> Option<Vec<Gc<Pat>>> {
+    if is_unguarded(a) {
+        Some(/* FIXME (#2543) */ a.pats.clone())
+    } else {
+        None
+    }
+}
+
 /// Generate a "pretty" name for an `impl` from its type and trait.
 /// This is designed so that symbols of `impl`'d methods give some
 /// hint of where they came from, (previously they would all just be

branches/auto/src/test/bench/shootout-regex-dna.rs

@@ -38,8 +38,6 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// FIXME(#13725) windows needs fixing.
-// ignore-windows
 // ignore-stage1
 // ignore-cross-compile #12102
 

branches/auto/src/test/compile-fail-fulldeps/syntax-extension-regex-invalid.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME(#13725) windows needs fixing.
-// ignore-windows
 // ignore-stage1
 
 #![feature(phase)]

branches/auto/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME(#13725) windows needs fixing.
-// ignore-windows
 // ignore-stage1
 
 #![feature(phase)]

branches/auto/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME(#13725) windows needs fixing.
-// ignore-windows
 // ignore-stage1
 
 #![feature(phase)]