---

yaml
---
r: 64201
b: refs/heads/snap-stage3
c: 9239d69
h: refs/heads/master
i:
  64199: 09a05b8
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 00da76dfbe3aba8c1ec399ecfa0eae4b4ba6885e
+refs/heads/snap-stage3: 9239d697889465dec4da1b30d13d731b96a0f40d
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -543,7 +543,8 @@ pub fn parse_type_param_def_data(data: &[u8], start: uint,
 }
 
 fn parse_type_param_def(st: &mut PState, conv: conv_did) -> ty::TypeParameterDef {
-    ty::TypeParameterDef {def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
+    ty::TypeParameterDef {ident: parse_ident(st, ':'),
+                          def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
                           bounds: @parse_bounds(st, |x,y| conv(x,y))}
 }
 

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

@@ -416,6 +416,8 @@ fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
 }
 
 pub fn enc_type_param_def(w: @io::Writer, cx: @ctxt, v: &ty::TypeParameterDef) {
+    w.write_str(cx.tcx.sess.str_of(v.ident));
+    w.write_char(':');
     w.write_str((cx.ds)(v.def_id));
     w.write_char('|');
     enc_bounds(w, cx, v.bounds);

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

@@ -130,6 +130,7 @@ impl Subst for ty::ParamBounds {
 impl Subst for ty::TypeParameterDef {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::TypeParameterDef {
         ty::TypeParameterDef {
+            ident: self.ident,
             def_id: self.def_id,
             bounds: self.bounds.subst(tcx, substs)
         }

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

@@ -794,6 +794,7 @@ impl ToStr for IntVarValue {
 }
 
 pub struct TypeParameterDef {
+    ident: ast::ident,
     def_id: ast::def_id,
     bounds: @ParamBounds
 }

branches/snap-stage3/src/librustc/middle/typeck/collect.rs

@@ -59,6 +59,7 @@ use syntax::print::pprust::{path_to_str, explicit_self_to_str};
 use syntax::visit;
 use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
+use syntax::parse::token::special_idents;
 
 pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
     fn collect_intrinsic_type(ccx: &CrateCtxt,
@@ -318,6 +319,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
         let self_trait_def = get_trait_def(ccx, local_def(trait_id));
         let self_trait_ref = self_trait_def.trait_ref.subst(tcx, &substs);
         new_type_param_defs.push(ty::TypeParameterDef {
+            ident: special_idents::self_,
             def_id: dummy_defid,
             bounds: @ty::ParamBounds {
                 builtin_bounds: ty::EmptyBuiltinBounds(),
@@ -1151,6 +1153,7 @@ pub fn ty_generics(ccx: &CrateCtxt,
                     let bounds = @compute_bounds(ccx, rp, generics,
                                                  param_ty, &param.bounds);
                     let def = ty::TypeParameterDef {
+                        ident: param.ident,
                         def_id: local_def(param.id),
                         bounds: bounds
                     };

branches/snap-stage3/src/librustc/util/ppaux.rs

@@ -435,16 +435,17 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
       ty_infer(infer_ty) => infer_ty.to_str(),
       ty_err => ~"[type error]",
       ty_param(param_ty {idx: id, def_id: did}) => {
-          let mut parm = (('T' as uint) + id) as char;
-          if (parm as uint) > ('Z' as uint) {
-              parm = (parm as uint - 26) as char;
-          }
-
-          if cx.sess.verbose() {
-              fmt!("%c:%?", parm, did)
-          } else {
-              fmt!("%c", parm)
-          }
+          let param_def = cx.ty_param_defs.find(&did.node);
+          let ident = match param_def {
+              Some(def) => {
+                  cx.sess.str_of(def.ident).to_owned()
+              }
+              None => {
+                  // This should not happen...
+                  fmt!("BUG[%?]", id)
+              }
+          };
+          if !cx.sess.verbose() { ident } else { fmt!("%s:%?", ident, did) }
       }
       ty_self(*) => ~"Self",
       ty_enum(did, ref substs) | ty_struct(did, ref substs) => {

branches/snap-stage3/src/libstd/cast.rs

@@ -13,7 +13,6 @@
 use sys;
 use unstable::intrinsics;
 
-/// Casts the value at `src` to U. The two types must have the same length.
 /// Casts the value at `src` to U. The two types must have the same length.
 #[cfg(target_word_size = "32")]
 #[inline]

branches/snap-stage3/src/libstd/iterator.rs

@@ -47,49 +47,6 @@ pub trait Iterator<A> {
     fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
 }
 
-/// A range iterator able to yield elements from both ends
-pub trait DoubleEndedIterator<A>: Iterator<A> {
-    /// Yield an element from the end of the range, returning `None` if the range is empty.
-    fn next_back(&mut self) -> Option<A>;
-}
-
-/// Iterator adaptors provided for every `DoubleEndedIterator` implementation.
-///
-/// In the future these will be default methods instead of a utility trait.
-pub trait DoubleEndedIteratorUtil<A> {
-    /// Flip the direction of the iterator
-    fn invert(self) -> InvertIterator<A, Self>;
-}
-
-/// Iterator adaptors provided for every `DoubleEndedIterator` implementation.
-///
-/// In the future these will be default methods instead of a utility trait.
-impl<A, T: DoubleEndedIterator<A>> DoubleEndedIteratorUtil<A> for T {
-    /// Flip the direction of the iterator
-    #[inline]
-    fn invert(self) -> InvertIterator<A, T> {
-        InvertIterator{iter: self}
-    }
-}
-
-/// An double-ended iterator with the direction inverted
-// FIXME #6967: Dummy A parameter to get around type inference bug
-pub struct InvertIterator<A, T> {
-    priv iter: T
-}
-
-impl<A, T: DoubleEndedIterator<A>> Iterator<A> for InvertIterator<A, T> {
-    #[inline]
-    fn next(&mut self) -> Option<A> { self.iter.next_back() }
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
-}
-
-impl<A, T: Iterator<A>> DoubleEndedIterator<A> for InvertIterator<A, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<A> { self.iter.next() }
-}
-
 /// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
 /// implementations of the `Iterator` trait.
 ///
@@ -1517,13 +1474,4 @@ mod tests {
         let xs = [-3, 0, 1, 5, -10];
         assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
     }
-
-    #[test]
-    fn test_invert() {
-        let xs = [2, 4, 6, 8, 10, 12, 14, 16];
-        let mut it = xs.iter();
-        it.next();
-        it.next();
-        assert_eq!(it.invert().transform(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]);
-    }
 }

branches/snap-stage3/src/libstd/libc.rs

@@ -186,6 +186,13 @@ pub mod types {
     // Standard types that are opaque or common, so are not per-target.
     pub mod common {
         pub mod c95 {
+            /**
+            Type used to construct void pointers for use with C.
+
+            This type is only useful as a pointer target. Do not use it as a
+            return type for FFI functions which have the `void` return type in
+            C. Use the unit type `()` or omit the return type instead.
+            */
             pub enum c_void {}
             pub enum FILE {}
             pub enum fpos_t {}

branches/snap-stage3/src/libstd/repr.rs

@@ -206,11 +206,13 @@ impl ReprVisitor {
                            inner: *TyDesc)
                            -> bool {
         let mut p = ptr;
-        let end = ptr::offset(p, len);
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
         self.writer.write_char('[');
         let mut first = true;
-        while (p as uint) < (end as uint) {
+        let mut left = len;
+        // unit structs have 0 size, and don't loop forever.
+        let dec = if sz == 0 {1} else {sz};
+        while left > 0 {
             if first {
                 first = false;
             } else {
@@ -219,6 +221,7 @@ impl ReprVisitor {
             self.write_mut_qualifier(mtbl);
             self.visit_ptr_inner(p as *c_void, inner);
             p = align(ptr::offset(p, sz) as uint, al) as *u8;
+            left -= dec;
         }
         self.writer.write_char(']');
         true
@@ -635,4 +638,7 @@ fn test_repr() {
                "(10, ~\"hello\")");
     exact_test(&(10_u64, ~"hello"),
                "(10, ~\"hello\")");
+
+    struct Foo;
+    exact_test(&(~[Foo, Foo, Foo]), "~[{}, {}, {}]");
 }