---

yaml
---
r: 68826
b: refs/heads/auto
c: fd5f8d9
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -14,6 +14,6 @@ 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: 990dc435aaf4861c6c57d2f94e3964b6c0918a87
+refs/heads/auto: fd5f8d90c5cc593e6aa43a978a1498f88558cc39
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/metadata/tydecode.rs

@@ -543,8 +543,7 @@ 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 {ident: parse_ident(st, ':'),
-                          def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
+    ty::TypeParameterDef {def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
                           bounds: @parse_bounds(st, |x,y| conv(x,y))}
 }
 

branches/auto/src/librustc/metadata/tyencode.rs

@@ -416,8 +416,6 @@ 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/auto/src/librustc/middle/subst.rs

@@ -130,7 +130,6 @@ 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/auto/src/librustc/middle/trans/base.rs

@@ -59,6 +59,7 @@ use middle::trans::type_of::*;
 use middle::ty;
 use util::common::indenter;
 use util::ppaux::{Repr, ty_to_str};
+use middle::pat_util;
 
 use middle::trans::type_::Type;
 

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

@@ -20,6 +20,7 @@ use std::vec;
 
 use back::abi;
 use driver::session;
+use lib;
 use lib::llvm::ValueRef;
 use lib::llvm::llvm;
 use metadata::csearch;

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

@@ -29,6 +29,7 @@ use std::hash;
 use std::hashmap::{HashMap, HashSet};
 use std::str;
 use std::local_data;
+use extra::time;
 use syntax::ast;
 
 use middle::trans::common::{mono_id,ExternMap,tydesc_info,BuilderRef_res,Stats};

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

@@ -248,6 +248,7 @@ pub fn trans_break_cont(bcx: block,
     let mut unwind = bcx;
     let mut cur_scope = unwind.scope;
     let mut target = unwind;
+    let mut quit = false;
     loop {
         cur_scope = match cur_scope {
             Some(@scope_info {

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

@@ -100,6 +100,7 @@ use middle::trans::glue;
 use middle::trans::tvec;
 use middle::trans::type_of;
 use middle::trans::write_guard;
+use middle::trans::type_::Type;
 use middle::ty;
 use util::common::indenter;
 use util::ppaux::ty_to_str;

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

@@ -39,6 +39,7 @@ use middle::trans::type_::Type;
 use std::io;
 use std::libc::c_uint;
 use std::str;
+use extra::time;
 use syntax::ast;
 
 pub fn trans_free(cx: block, v: ValueRef) -> block {

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

@@ -548,7 +548,7 @@ pub fn trans_trait_callee_from_llval(bcx: block,
 
     let _icx = push_ctxt("impl::trans_trait_callee");
     let ccx = bcx.ccx();
-    let bcx = bcx;
+    let mut bcx = bcx;
 
     // Load the vtable from the @Trait pair
     debug!("(translating trait callee) loading vtable from pair %s",

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

@@ -19,6 +19,7 @@ use middle::trans::glue;
 use middle::ty;
 use middle::trans::machine::llsize_of;
 use middle::trans::type_of;
+use middle::trans::type_of::*;
 
 pub fn make_free_glue(bcx: block, vptrptr: ValueRef, box_ty: ty::t)
     -> block {

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

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

branches/auto/src/librustc/middle/typeck/collect.rs

@@ -59,7 +59,6 @@ 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,
@@ -319,7 +318,6 @@ 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(),
@@ -1153,7 +1151,6 @@ 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/auto/src/librustc/util/ppaux.rs

@@ -435,17 +435,16 @@ 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 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) }
+          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)
+          }
       }
       ty_self(*) => ~"Self",
       ty_enum(did, ref substs) | ty_struct(did, ref substs) => {

branches/auto/src/libstd/iterator.rs

@@ -47,6 +47,49 @@ 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.
 ///
@@ -1474,4 +1517,13 @@ 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/auto/src/libstd/repr.rs

@@ -206,13 +206,11 @@ 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;
-        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 {
+        while (p as uint) < (end as uint) {
             if first {
                 first = false;
             } else {
@@ -221,7 +219,6 @@ 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
@@ -638,7 +635,4 @@ fn test_repr() {
                "(10, ~\"hello\")");
     exact_test(&(10_u64, ~"hello"),
                "(10, ~\"hello\")");
-
-    struct Foo;
-    exact_test(&(~[Foo, Foo, Foo]), "~[{}, {}, {}]");
 }