---

yaml
---
r: 67316
b: refs/heads/master
c: b1f5b1b
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: af7b87f69d9c4633d7e0c7dd77f34c23bbd433d8
+refs/heads/master: b1f5b1ba5fd12a058d153e9da8f11cd1bc597bf0
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/librustc/metadata/tydecode.rs

@@ -186,7 +186,7 @@ fn parse_trait_store(st: &mut PState) -> ty::TraitStore {
 }
 
 fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
-    let self_r = parse_opt(st, |st| parse_region(st) );
+    let regions = parse_region_substs(st, |x,y| conv(x,y));
 
     let self_ty = parse_opt(st, |st| parse_ty(st, |x,y| conv(x,y)) );
 
@@ -196,12 +196,28 @@ fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
     st.pos = st.pos + 1u;
 
     return ty::substs {
-        self_r: self_r,
+        regions: regions,
         self_ty: self_ty,
         tps: params
     };
 }
 
+fn parse_region_substs(st: &mut PState, conv: conv_did) -> ty::RegionSubsts {
+    match next(st) {
+        'e' => ty::ErasedRegions,
+        'n' => {
+            let mut regions = opt_vec::Empty;
+            while peek(st) != '.' {
+                let r = parse_region(st);
+                regions.push(r);
+            }
+            assert_eq!(next(st), '.');
+            ty::NonerasedRegions(regions)
+        }
+        _ => fail!("parse_bound_region: bad input")
+    }
+}
+
 fn parse_bound_region(st: &mut PState) -> ty::bound_region {
     match next(st) {
       's' => ty::br_self,

trunk/src/librustc/metadata/tyencode.rs

@@ -120,13 +120,28 @@ fn enc_opt<T>(w: @io::Writer, t: Option<T>, enc_f: &fn(T)) {
 }
 
 fn enc_substs(w: @io::Writer, cx: @ctxt, substs: &ty::substs) {
-    do enc_opt(w, substs.self_r) |r| { enc_region(w, cx, r) }
+    enc_region_substs(w, cx, &substs.regions);
     do enc_opt(w, substs.self_ty) |t| { enc_ty(w, cx, t) }
     w.write_char('[');
     for substs.tps.iter().advance |t| { enc_ty(w, cx, *t); }
     w.write_char(']');
 }
 
+fn enc_region_substs(w: @io::Writer, cx: @ctxt, substs: &ty::RegionSubsts) {
+    match *substs {
+        ty::ErasedRegions => {
+            w.write_char('e');
+        }
+        ty::NonerasedRegions(ref regions) => {
+            w.write_char('n');
+            for regions.iter().advance |&r| {
+                enc_region(w, cx, r);
+            }
+            w.write_char('.');
+        }
+    }
+}
+
 fn enc_region(w: @io::Writer, cx: @ctxt, r: ty::Region) {
     match r {
       ty::re_bound(br) => {

trunk/src/librustc/middle/check_match.rs

@@ -10,7 +10,7 @@
 
 
 use middle::const_eval::{compare_const_vals, lookup_const_by_id};
-use middle::const_eval::{eval_const_expr, const_val, const_bool};
+use middle::const_eval::{eval_const_expr, const_val, const_bool, const_float};
 use middle::pat_util::*;
 use middle::ty::*;
 use middle::ty;
@@ -102,6 +102,27 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) {
     let mut seen = ~[];
     for arms.iter().advance |arm| {
         for arm.pats.iter().advance |pat| {
+
+            // Check that we do not match against a static NaN (#6804)
+            let pat_matches_nan: &fn(@pat) -> bool = |p| {
+                match cx.tcx.def_map.find(&p.id) {
+                    Some(&def_static(did, false)) => {
+                        let const_expr = lookup_const_by_id(cx.tcx, did).get();
+                        match eval_const_expr(cx.tcx, const_expr) {
+                            const_float(f) if f.is_NaN() => true,
+                            _ => false
+                        }
+                    }
+                    _ => false
+                }
+            };
+            for walk_pat(*pat) |p| {
+                if pat_matches_nan(p) {
+                    cx.tcx.sess.span_warn(p.span, "unmatchable NaN in pattern, \
+                                                   use the is_NaN method in a guard instead");
+                }
+            }
+
             let v = ~[*pat];
             match is_useful(cx, &seen, v) {
               not_useful => {

trunk/src/librustc/middle/kind.rs

@@ -19,6 +19,7 @@ use util::ppaux::UserString;
 use syntax::ast::*;
 use syntax::attr;
 use syntax::codemap::span;
+use syntax::opt_vec;
 use syntax::print::pprust::expr_to_str;
 use syntax::{visit, ast_util};
 
@@ -83,7 +84,7 @@ fn check_struct_safe_for_destructor(cx: Context,
     let struct_tpt = ty::lookup_item_type(cx.tcx, struct_did);
     if !struct_tpt.generics.has_type_params() {
         let struct_ty = ty::mk_struct(cx.tcx, struct_did, ty::substs {
-            self_r: None,
+            regions: ty::NonerasedRegions(opt_vec::Empty),
             self_ty: None,
             tps: ~[]
         });

trunk/src/librustc/middle/subst.rs

@@ -12,6 +12,7 @@
 
 
 use middle::ty;
+use syntax::opt_vec::OptVec;
 use util::ppaux::Repr;
 
 ///////////////////////////////////////////////////////////////////////////
@@ -79,6 +80,12 @@ impl<T:Subst> Subst for ~[T] {
     }
 }
 
+impl<T:Subst> Subst for OptVec<T> {
+    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> OptVec<T> {
+        self.map(|t| t.subst(tcx, substs))
+    }
+}
+
 impl<T:Subst + 'static> Subst for @T {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @T {
         match self {
@@ -105,13 +112,26 @@ impl Subst for ty::TraitRef {
 impl Subst for ty::substs {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::substs {
         ty::substs {
-            self_r: self.self_r.subst(tcx, substs),
+            regions: self.regions.subst(tcx, substs),
             self_ty: self.self_ty.map(|typ| typ.subst(tcx, substs)),
             tps: self.tps.map(|typ| typ.subst(tcx, substs))
         }
     }
 }
 
+impl Subst for ty::RegionSubsts {
+    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::RegionSubsts {
+        match *self {
+            ty::ErasedRegions => {
+                ty::ErasedRegions
+            }
+            ty::NonerasedRegions(ref regions) => {
+                ty::NonerasedRegions(regions.subst(tcx, substs))
+            }
+        }
+    }
+}
+
 impl Subst for ty::BareFnTy {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::BareFnTy {
         ty::fold_bare_fn_ty(self, |t| t.subst(tcx, substs))
@@ -158,15 +178,18 @@ impl Subst for ty::Region {
         // will most likely disappear.
         match self {
             &ty::re_bound(ty::br_self) => {
-                match substs.self_r {
-                    None => {
-                        tcx.sess.bug(
-                            fmt!("ty::Region#subst(): \
-                                  Reference to self region when \
-                                  given substs with no self region: %s",
-                                 substs.repr(tcx)));
+                match substs.regions {
+                    ty::ErasedRegions => ty::re_static,
+                    ty::NonerasedRegions(ref regions) => {
+                        if regions.len() != 1 {
+                            tcx.sess.bug(
+                                fmt!("ty::Region#subst(): \
+                                      Reference to self region when \
+                                      given substs with no self region: %s",
+                                     substs.repr(tcx)));
+                        }
+                        *regions.get(0)
                     }
-                    Some(self_r) => self_r
                 }
             }
             _ => *self

trunk/src/librustc/middle/trans/base.rs

@@ -515,7 +515,8 @@ pub fn get_res_dtor(ccx: @mut CrateContext,
             did
         };
         assert_eq!(did.crate, ast::local_crate);
-        let tsubsts = ty::substs { self_r: None, self_ty: None,
+        let tsubsts = ty::substs {regions: ty::ErasedRegions,
+                                  self_ty: None,
                                   tps: /*bad*/ substs.to_owned() };
         let (val, _) = monomorphize::monomorphic_fn(ccx,
                                                     did,

trunk/src/librustc/middle/trans/callee.rs

@@ -274,15 +274,10 @@ pub fn trans_fn_ref_with_vtables(
     // Polytype of the function item (may have type params)
     let fn_tpt = ty::lookup_item_type(tcx, def_id);
 
-    // For simplicity, we want to use the Subst trait when composing
-    // substitutions for default methods.  The subst trait does
-    // substitutions with regions, though, so we put a dummy self
-    // region parameter in to keep it from failing. This is a hack.
-    let substs = ty::substs { self_r: Some(ty::re_empty),
+    let substs = ty::substs { regions: ty::ErasedRegions,
                               self_ty: None,
                               tps: /*bad*/ type_params.to_owned() };
 
-
     // We need to do a bunch of special handling for default methods.
     // We need to modify the def_id and our substs in order to monomorphize
     // the function.

trunk/src/librustc/middle/trans/common.rs

@@ -1103,7 +1103,7 @@ pub fn find_vtable(tcx: ty::ctxt,
 
 pub fn dummy_substs(tps: ~[ty::t]) -> ty::substs {
     substs {
-        self_r: Some(ty::re_bound(ty::br_self)),
+        regions: ty::ErasedRegions,
         self_ty: None,
         tps: tps
     }