---

yaml
---
r: 219519
b: refs/heads/snap-stage3
c: 3f9fc39
h: refs/heads/master
i:
  219517: ced5ace
  219515: d6b7092
  219511: 9933e17
  219503: 58ff664
  219487: e696f19
  219455: aeb1096
  219391: 298946b
v: v3

Author: GuillaumeGomez

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: 3223c885b925d0cde92aaf900fa32dbcc5c8318c
+refs/heads/snap-stage3: 3f9fc39ab91a4d75b9499d3b3591db875649a0b7
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/doc/style/features/traits/generics.md

@@ -8,7 +8,7 @@ yielding items of type `A` to produce a collection of `A`:
 fn from_iter<T: Iterator<A>>(iterator: T) -> SomeCollection<A>
 ```
 
-Here, the `Iterator` trait specifies an interface that a type `T` must
+Here, the `Iterator` trait is specifies an interface that a type `T` must
 explicitly implement to be used by this generic function.
 
 **Pros**:

branches/snap-stage3/src/doc/trpl/error-handling.md

@@ -225,9 +225,9 @@ There's another way of doing this that's a bit nicer than `unwrap()`:
 
 ```rust,ignore
 let mut buffer = String::new();
-let num_bytes_read = io::stdin().read_line(&mut buffer)
-                                .ok()
-                                .expect("Failed to read line");
+let input = io::stdin().read_line(&mut buffer)
+                       .ok()
+                       .expect("Failed to read line");
 ```
 
 `ok()` converts the `Result` into an `Option`, and `expect()` does the same

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -195,6 +195,15 @@ pub fn parse_substs_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: us
     parse_substs(&mut st, conv)
 }
 
+pub fn parse_bounds_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum,
+                                  pos: usize, tcx: &ty::ctxt<'tcx>, conv: F)
+                                  -> ty::ParamBounds<'tcx> where
+    F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
+{
+    let mut st = parse_state_from_data(data, crate_num, pos, tcx);
+    parse_bounds(&mut st, conv)
+}
+
 pub fn parse_existential_bounds_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum,
                                               pos: usize, tcx: &ty::ctxt<'tcx>, conv: F)
                                               -> ty::ExistentialBounds<'tcx> where
@@ -870,23 +879,11 @@ fn parse_existential_bounds_<'a,'tcx, F>(st: &mut PState<'a,'tcx>,
                                         -> ty::ExistentialBounds<'tcx> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
-    let builtin_bounds = parse_builtin_bounds_(st, conv);
-    let region_bound = parse_region_(st, conv);
-    let mut projection_bounds = Vec::new();
-
-    loop {
-        match next(st) {
-            'P' => {
-                projection_bounds.push(
-                    ty::Binder(parse_projection_predicate_(st, conv)));
-                }
-            '.' => { break; }
-            c => {
-                panic!("parse_bounds: bad bounds ('{}')", c)
-            }
-        }
-    }
-
+    let ty::ParamBounds { trait_bounds, mut region_bounds, builtin_bounds, projection_bounds } =
+         parse_bounds_(st, conv);
+    assert_eq!(region_bounds.len(), 1);
+    assert_eq!(trait_bounds.len(), 0);
+    let region_bound = region_bounds.pop().unwrap();
     return ty::ExistentialBounds { region_bound: region_bound,
                                    builtin_bounds: builtin_bounds,
                                    projection_bounds: projection_bounds };
@@ -926,3 +923,60 @@ fn parse_builtin_bounds_<F>(st: &mut PState, _conv: &mut F) -> ty::BuiltinBounds
         }
     }
 }
+
+fn parse_bounds<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, mut conv: F)
+                             -> ty::ParamBounds<'tcx> where
+    F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
+{
+    parse_bounds_(st, &mut conv)
+}
+
+fn parse_bounds_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F)
+                              -> ty::ParamBounds<'tcx> where
+    F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
+{
+    let builtin_bounds = parse_builtin_bounds_(st, conv);
+
+    let region_bounds = parse_region_bounds_(st, conv);
+
+    let mut param_bounds = ty::ParamBounds {
+        region_bounds: region_bounds,
+        builtin_bounds: builtin_bounds,
+        trait_bounds: Vec::new(),
+        projection_bounds: Vec::new(),
+    };
+
+
+    loop {
+        match next(st) {
+            'I' => {
+                param_bounds.trait_bounds.push(
+                    ty::Binder(parse_trait_ref_(st, conv)));
+            }
+            'P' => {
+                param_bounds.projection_bounds.push(
+                    ty::Binder(parse_projection_predicate_(st, conv)));
+            }
+            '.' => {
+                return param_bounds;
+            }
+            c => {
+                panic!("parse_bounds: bad bounds ('{}')", c)
+            }
+        }
+    }
+}
+
+fn parse_region_bounds_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F)
+                              -> Vec<ty::Region> where
+    F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
+{
+    let mut region_bounds = Vec::new();
+    loop {
+        match next(st) {
+            'R' => { region_bounds.push(parse_region_(st, conv)); }
+            '.' => { return region_bounds; }
+            c => { panic!("parse_bounds: bad bounds ('{}')", c); }
+        }
+    }
+}

branches/snap-stage3/src/librustc/metadata/tyencode.rs

@@ -380,9 +380,23 @@ pub fn enc_builtin_bounds(w: &mut Encoder, _cx: &ctxt, bs: &ty::BuiltinBounds) {
 pub fn enc_existential_bounds<'a,'tcx>(w: &mut Encoder,
                                        cx: &ctxt<'a,'tcx>,
                                        bs: &ty::ExistentialBounds<'tcx>) {
+    let param_bounds = ty::ParamBounds { trait_bounds: vec!(),
+                                         region_bounds: vec!(bs.region_bound),
+                                         builtin_bounds: bs.builtin_bounds,
+                                         projection_bounds: bs.projection_bounds.clone() };
+    enc_bounds(w, cx, &param_bounds);
+}
+
+pub fn enc_bounds<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>,
+                            bs: &ty::ParamBounds<'tcx>) {
     enc_builtin_bounds(w, cx, &bs.builtin_bounds);
 
-    enc_region(w, cx, bs.region_bound);
+    enc_region_bounds(w, cx, &bs.region_bounds);
+
+    for tp in &bs.trait_bounds {
+        mywrite!(w, "I");
+        enc_trait_ref(w, cx, tp.0);
+    }
 
     for tp in &bs.projection_bounds {
         mywrite!(w, "P");

branches/snap-stage3/src/librustc/middle/check_match.rs

@@ -12,7 +12,7 @@ pub use self::Constructor::*;
 use self::Usefulness::*;
 use self::WitnessPreference::*;
 
-use middle::const_eval::{compare_const_vals, ConstVal};
+use middle::const_eval::{compare_const_vals, const_bool, const_float, const_val};
 use middle::const_eval::{eval_const_expr, eval_const_expr_partial};
 use middle::const_eval::{const_expr_to_pat, lookup_const_by_id};
 use middle::def::*;
@@ -111,9 +111,9 @@ pub enum Constructor {
     /// Enum variants.
     Variant(ast::DefId),
     /// Literal values.
-    ConstantValue(ConstVal),
+    ConstantValue(const_val),
     /// Ranges of literal values (2..5).
-    ConstantRange(ConstVal, ConstVal),
+    ConstantRange(const_val, const_val),
     /// Array patterns of length n.
     Slice(usize),
     /// Array patterns with a subslice.
@@ -262,7 +262,7 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) {
     ast_util::walk_pat(pat, |p| {
         if let ast::PatLit(ref expr) = p.node {
             match eval_const_expr_partial(cx.tcx, &**expr, None) {
-                Ok(ConstVal::Float(f)) if f.is_nan() => {
+                Ok(const_float(f)) if f.is_nan() => {
                     span_warn!(cx.tcx.sess, p.span, E0003,
                                "unmatchable NaN in pattern, \
                                 use the is_nan method in a guard instead");
@@ -391,9 +391,9 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix, source: ast:
     }
 }
 
-fn const_val_to_expr(value: &ConstVal) -> P<ast::Expr> {
+fn const_val_to_expr(value: &const_val) -> P<ast::Expr> {
     let node = match value {
-        &ConstVal::Bool(b) => ast::LitBool(b),
+        &const_bool(b) => ast::LitBool(b),
         _ => unreachable!()
     };
     P(ast::Expr {
@@ -596,7 +596,7 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
                     max_slice_length: usize) -> Vec<Constructor> {
     match left_ty.sty {
         ty::TyBool =>
-            [true, false].iter().map(|b| ConstantValue(ConstVal::Bool(*b))).collect(),
+            [true, false].iter().map(|b| ConstantValue(const_bool(*b))).collect(),
 
         ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty {
             ty::TySlice(_) =>
@@ -826,7 +826,7 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi
 }
 
 fn range_covered_by_constructor(ctor: &Constructor,
-                                from: &ConstVal, to: &ConstVal) -> Option<bool> {
+                                from: &const_val, to: &const_val) -> Option<bool> {
     let (c_from, c_to) = match *ctor {
         ConstantValue(ref value)        => (value, value),
         ConstantRange(ref from, ref to) => (from, to),