---

yaml
---
r: 119002
b: refs/heads/auto
c: 37b8ce0
h: refs/heads/master
v: v3

Author: Sawyer47

[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: d77cb22bb6e5852c99d4c8f5d9de4b33b1b9381b
+refs/heads/auto: 37b8ce006475bba311d275d631cd3494937355fc
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide-container.md

@@ -26,7 +26,7 @@ The standard library provides three owned map/set types:
   implement `Eq` and `Hash`
 * `collections::TrieMap` and `collections::TrieSet`, requiring the keys to be `uint`
 * `collections::TreeMap` and `collections::TreeSet`, requiring the keys
-  to implement `Ord`
+  to implement `TotalOrd`
 
 These maps do not use managed pointers so they can be sent between tasks as
 long as the key and value types are sendable. Neither the key or value type has

branches/auto/src/doc/rust.md

@@ -2270,7 +2270,7 @@ impl<T: PartialEq> PartialEq for Foo<T> {
 
 Supported traits for `deriving` are:
 
-* Comparison traits: `PartialEq`, `Eq`, `PartialOrd`, `Ord`.
+* Comparison traits: `PartialEq`, `TotalEq`, `PartialOrd`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `serialize`.
 * `Clone`, to create `T` from `&T` via a copy.
 * `Hash`, to iterate over the bytes in a data type.

branches/auto/src/doc/tutorial.md

@@ -2619,8 +2619,8 @@ fn main() {
 }
 ~~~
 
-The full list of derivable traits is `PartialEq`, `Eq`, `PartialOrd`,
-`Ord`, `Encodable`, `Decodable`, `Clone`,
+The full list of derivable traits is `PartialEq`, `TotalEq`, `Ord`,
+`TotalOrd`, `Encodable`, `Decodable`, `Clone`,
 `Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system

branches/auto/src/etc/2014-06-rewrite-bytes-macros.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/bin/env python
 #
 # Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 # file at the top-level directory of this distribution and at

branches/auto/src/etc/generate-deriving-span-tests.py

@@ -119,8 +119,8 @@ def write_file(name, string):
                               ('Clone', [], 1),
                               ('PartialEq', [], 2),
                               ('PartialOrd', ['PartialEq'], 8),
-                              ('Eq', ['PartialEq'], 1),
-                              ('Ord', ['Eq', 'PartialOrd', 'PartialEq'], 1),
+                              ('TotalEq', ['PartialEq'], 1),
+                              ('TotalOrd', ['TotalEq', 'PartialOrd', 'PartialEq'], 1),
                               ('Show', [], 1),
                               ('Hash', [], 1)]:
     traits[trait] = (ALL, supers, errs)

branches/auto/src/etc/vim/syntax/rust.vim

@@ -82,7 +82,7 @@ syn keyword rustTrait Ascii AsciiCast OwnedAsciiCast AsciiStr IntoBytes
 syn keyword rustTrait ToCStr
 syn keyword rustTrait Char
 syn keyword rustTrait Clone
-syn keyword rustTrait Eq Ord PartialEq PartialOrd Ordering Equiv
+syn keyword rustTrait Eq Ord TotalEq TotalOrd Ordering Equiv
 syn keyword rustEnumVariant Less Equal Greater
 syn keyword rustTrait Container Mutable Map MutableMap Set MutableSet
 syn keyword rustTrait FromIterator Extendable
@@ -104,7 +104,7 @@ syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
 syn keyword rustTrait Tuple9 Tuple10 Tuple11 Tuple12
 syn keyword rustTrait CloneableVector ImmutableCloneableVector MutableCloneableVector
 syn keyword rustTrait ImmutableVector MutableVector
-syn keyword rustTrait ImmutableEqVector ImmutableOrdVector MutableOrdVector
+syn keyword rustTrait ImmutableEqVector ImmutableTotalOrdVector MutableTotalOrdVector
 syn keyword rustTrait Vector VectorVector OwnedVector MutableVectorAllocating
 syn keyword rustTrait String
 syn keyword rustTrait Vec

branches/auto/src/libcollections/vec.rs

@@ -85,7 +85,6 @@ impl<T> Vec<T> {
     /// # use std::vec::Vec;
     /// let vec: Vec<int> = Vec::with_capacity(10);
     /// ```
-    #[inline]
     pub fn with_capacity(capacity: uint) -> Vec<T> {
         if mem::size_of::<T>() == 0 {
             Vec { len: 0, cap: uint::MAX, ptr: 0 as *mut T }
@@ -111,7 +110,6 @@ impl<T> Vec<T> {
     /// let vec = Vec::from_fn(3, |idx| idx * 2);
     /// assert_eq!(vec, vec!(0, 2, 4));
     /// ```
-    #[inline]
     pub fn from_fn(length: uint, op: |uint| -> T) -> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
@@ -195,7 +193,6 @@ impl<T: Clone> Vec<T> {
     /// let slice = [1, 2, 3];
     /// let vec = Vec::from_slice(slice);
     /// ```
-    #[inline]
     pub fn from_slice(values: &[T]) -> Vec<T> {
         values.iter().map(|x| x.clone()).collect()
     }
@@ -210,7 +207,6 @@ impl<T: Clone> Vec<T> {
     /// let vec = Vec::from_elem(3, "hi");
     /// println!("{}", vec); // prints [hi, hi, hi]
     /// ```
-    #[inline]
     pub fn from_elem(length: uint, value: T) -> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
@@ -357,7 +353,6 @@ impl<T:Clone> Clone for Vec<T> {
 }
 
 impl<T> FromIterator<T> for Vec<T> {
-    #[inline]
     fn from_iter<I:Iterator<T>>(mut iterator: I) -> Vec<T> {
         let (lower, _) = iterator.size_hint();
         let mut vector = Vec::with_capacity(lower);
@@ -369,7 +364,6 @@ impl<T> FromIterator<T> for Vec<T> {
 }
 
 impl<T> Extendable<T> for Vec<T> {
-    #[inline]
     fn extend<I: Iterator<T>>(&mut self, mut iterator: I) {
         let (lower, _) = iterator.size_hint();
         self.reserve_additional(lower);
@@ -1035,7 +1029,6 @@ impl<T> Vec<T> {
     /// vec.push_all_move(vec!(box 2, box 3, box 4));
     /// assert_eq!(vec, vec!(box 1, box 2, box 3, box 4));
     /// ```
-    #[inline]
     pub fn push_all_move(&mut self, other: Vec<T>) {
         self.extend(other.move_iter());
     }
@@ -1313,7 +1306,6 @@ impl<T:PartialEq> Vec<T> {
     /// let vec = vec!(1, 2, 3);
     /// assert!(vec.contains(&1));
     /// ```
-    #[inline]
     pub fn contains(&self, x: &T) -> bool {
         self.as_slice().contains(x)
     }
@@ -1552,11 +1544,8 @@ pub mod raw {
 
 #[cfg(test)]
 mod tests {
-    extern crate test;
-
     use std::prelude::*;
     use std::mem::size_of;
-    use test::Bencher;
     use super::{unzip, raw, Vec};
 
     #[test]
@@ -1847,111 +1836,4 @@ mod tests {
         let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
         v.truncate(0);
     }
-
-    #[bench]
-    fn bench_new(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::new();
-            assert_eq!(v.capacity(), 0);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_with_capacity_0(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(0);
-            assert_eq!(v.capacity(), 0);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-
-    #[bench]
-    fn bench_with_capacity_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(5);
-            assert_eq!(v.capacity(), 5);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_with_capacity_100(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::with_capacity(100);
-            assert_eq!(v.capacity(), 100);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_from_fn_0(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::from_fn(0, |_| 5);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_from_fn_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::from_fn(5, |_| 5);
-            assert!(v.as_slice() == [5, 5, 5, 5, 5]);
-        })
-    }
-
-    #[bench]
-    fn bench_from_slice_0(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::from_slice([]);
-            assert!(v.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_from_slice_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v: Vec<int> = Vec::from_slice([1, 2, 3, 4, 5]);
-            assert!(v.as_slice() == [1, 2, 3, 4, 5]);
-        })
-    }
-
-    #[bench]
-    fn bench_from_iter_0(b: &mut Bencher) {
-        b.iter(|| {
-            let v0: Vec<int> = vec!();
-            let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
-            assert!(v1.as_slice() == []);
-        })
-    }
-
-    #[bench]
-    fn bench_from_iter_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
-            let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
-        })
-    }
-
-    #[bench]
-    fn bench_extend_0(b: &mut Bencher) {
-        b.iter(|| {
-            let v0: Vec<int> = vec!();
-            let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
-            v1.extend(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
-        })
-    }
-
-    #[bench]
-    fn bench_extend_5(b: &mut Bencher) {
-        b.iter(|| {
-            let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
-            let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
-            v1.extend(v0.move_iter());
-            assert!(v1.as_slice() == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]);
-        })
-    }
 }

branches/auto/src/librustc/front/feature_gate.rs

@@ -16,7 +16,7 @@
 //! enabled.
 //!
 //! Features are enabled in programs via the crate-level attributes of
-//! `#![feature(...)]` with a comma-separated list of features.
+//! #![feature(...)] with a comma-separated list of features.
 
 use middle::lint;
 

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

@@ -193,7 +193,7 @@ pub fn get_struct_fields(cstore: &cstore::CStore,
 
 pub fn get_type(tcx: &ty::ctxt,
                 def: ast::DefId)
-             -> ty::Polytype {
+             -> ty::ty_param_bounds_and_ty {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type(&*cdata, def.node, tcx)
@@ -206,7 +206,7 @@ pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef {
 }
 
 pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
-                      def: ast::DefId) -> ty::Polytype {
+                      def: ast::DefId) -> ty::ty_param_bounds_and_ty {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(class_id.krate);
     let all_items = reader::get_doc(ebml::Doc::new(cdata.data()), tag_items);
@@ -224,7 +224,7 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
                     def)).to_string()
         });
     let ty = decoder::item_type(def, the_field, tcx, &*cdata);
-    ty::Polytype {
+    ty::ty_param_bounds_and_ty {
         generics: ty::Generics {types: VecPerParamSpace::empty(),
                                 regions: VecPerParamSpace::empty()},
         ty: ty

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

@@ -422,7 +422,7 @@ pub fn get_trait_def(cdata: Cmd,
 }
 
 pub fn get_type(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt)
-    -> ty::Polytype {
+    -> ty::ty_param_bounds_and_ty {
 
     let item = lookup_item(id, cdata.data());
 
@@ -432,7 +432,7 @@ pub fn get_type(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt)
     let tp_defs = item_ty_param_defs(item, tcx, cdata, tag_items_data_item_ty_param_bounds);
     let rp_defs = item_region_param_defs(item, cdata);
 
-    ty::Polytype {
+    ty::ty_param_bounds_and_ty {
         generics: ty::Generics {types: tp_defs,
                                 regions: rp_defs},
         ty: t

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

@@ -196,11 +196,11 @@ fn encode_item_variances(ebml_w: &mut Encoder,
 
 fn encode_bounds_and_type(ebml_w: &mut Encoder,
                           ecx: &EncodeContext,
-                          pty: &ty::Polytype) {
-    encode_ty_type_param_defs(ebml_w, ecx, &pty.generics.types,
+                          tpt: &ty::ty_param_bounds_and_ty) {
+    encode_ty_type_param_defs(ebml_w, ecx, &tpt.generics.types,
                               tag_items_data_item_ty_param_bounds);
-    encode_region_param_defs(ebml_w, &pty.generics.regions);
-    encode_type(ecx, ebml_w, pty.ty);
+    encode_region_param_defs(ebml_w, &tpt.generics.regions);
+    encode_type(ecx, ebml_w, tpt.ty);
 }
 
 fn encode_variant_id(ebml_w: &mut Encoder, vid: DefId) {
@@ -772,8 +772,8 @@ fn encode_info_for_method(ecx: &EncodeContext,
     encode_stability(ebml_w, stab);
 
     // The type for methods gets encoded twice, which is unfortunate.
-    let pty = lookup_item_type(ecx.tcx, m.def_id);
-    encode_bounds_and_type(ebml_w, ecx, &pty);
+    let tpt = lookup_item_type(ecx.tcx, m.def_id);
+    encode_bounds_and_type(ebml_w, ecx, &tpt);
 
     let elem = ast_map::PathName(m.ident.name);
     encode_path(ebml_w, impl_path.chain(Some(elem).move_iter()));
@@ -785,7 +785,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
     }
 
     for &ast_method in ast_method_opt.iter() {
-        let any_types = !pty.generics.types.is_empty();
+        let any_types = !tpt.generics.types.is_empty();
         if any_types || is_default_impl || should_inline(ast_method.attrs.as_slice()) {
             encode_inlined_item(ecx, ebml_w,
                                 IIMethodRef(local_def(parent_id), false,
@@ -1218,8 +1218,8 @@ fn encode_info_for_item(ecx: &EncodeContext,
                                   fn_style_static_method_family(
                                       method_ty.fty.fn_style));
 
-                    let pty = ty::lookup_item_type(tcx, method_def_id);
-                    encode_bounds_and_type(ebml_w, ecx, &pty);
+                    let tpt = ty::lookup_item_type(tcx, method_def_id);
+                    encode_bounds_and_type(ebml_w, ecx, &tpt);
                 }
 
                 _ => {
@@ -1242,8 +1242,8 @@ fn encode_info_for_item(ecx: &EncodeContext,
                     // this.
                     if method_ty.explicit_self != SelfStatic {
                         // FIXME: I feel like there is something funny going on.
-                        let pty = ty::lookup_item_type(tcx, method_def_id);
-                        encode_bounds_and_type(ebml_w, ecx, &pty);
+                        let tpt = ty::lookup_item_type(tcx, method_def_id);
+                        encode_bounds_and_type(ebml_w, ecx, &tpt);
                     }
                     encode_method_sort(ebml_w, 'p');
                     encode_inlined_item(ecx, ebml_w,