---

yaml
---
r: 152764
b: refs/heads/try2
c: 020373f
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 768921371311430c8eb953bfdddece53a6071e6e
+refs/heads/try2: 020373f2c807627274a53251a7841f0e9617e98e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/src/doc/rust.md

@@ -160,7 +160,7 @@ block_comment_body : [block_comment | character] * ;
 line_comment : "//" non_eol * ;
 ~~~~
 
-Comments in Rust code follow the general C++ style of line and block-comment forms.
+Comments in Rust code follow the general C++ style of line and block-comment forms. 
 Nested block comments are supported.
 
 Line comments beginning with exactly _three_ slashes (`///`), and block
@@ -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.
@@ -3004,7 +3004,7 @@ ten_times(|j| println!("hello, {}", j));
 ### While loops
 
 ~~~~ {.ebnf .gram}
-while_expr : "while" no_struct_literal_expr '{' block '}' ;
+while_expr : "while" expr '{' block '}' ;
 ~~~~
 
 A `while` loop begins by evaluating the boolean loop conditional expression.
@@ -3071,7 +3071,7 @@ A `continue` expression is only permitted in the body of a loop.
 ### For expressions
 
 ~~~~ {.ebnf .gram}
-for_expr : "for" pat "in" no_struct_literal_expr '{' block '}' ;
+for_expr : "for" pat "in" expr '{' block '}' ;
 ~~~~
 
 A `for` expression is a syntactic construct for looping over elements
@@ -3105,7 +3105,7 @@ for i in range(0u, 256) {
 ### If expressions
 
 ~~~~ {.ebnf .gram}
-if_expr : "if" no_struct_literal_expr '{' block '}'
+if_expr : "if" expr '{' block '}'
           else_tail ? ;
 
 else_tail : "else" [ if_expr
@@ -3126,7 +3126,7 @@ then any `else` block is executed.
 ### Match expressions
 
 ~~~~ {.ebnf .gram}
-match_expr : "match" no_struct_literal_expr '{' match_arm * '}' ;
+match_expr : "match" expr '{' match_arm * '}' ;
 
 match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
 
@@ -3563,11 +3563,10 @@ There are four varieties of pointer in Rust:
 
 * Raw pointers (`*`)
   : Raw pointers are pointers without safety or liveness guarantees.
-    Raw pointers are written as `*const T` or `*mut T`,
-    for example `*const int` means a raw pointer to an integer.
-    Copying or dropping a raw pointer has no effect on the lifecycle of any
-    other value.  Dereferencing a raw pointer or converting it to any other
-    pointer type is an [`unsafe` operation](#unsafe-functions).
+    Raw pointers are written `*content`,
+    for example `*int` means a raw pointer to an integer.
+    Copying or dropping a raw pointer has no effect on the lifecycle of any other value.
+    Dereferencing a raw pointer or converting it to any other pointer type is an [`unsafe` operation](#unsafe-functions).
     Raw pointers are generally discouraged in Rust code;
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.

branches/try2/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/try2/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/try2/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/try2/src/etc/vim/syntax/rust.vim

@@ -30,7 +30,8 @@ syn keyword   rustKeyword     unsafe virtual while
 syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty
-syn keyword   rustStorage     mut ref static const
+syn keyword   rustStorage     mut ref static
+syn keyword   rustObsoleteStorage const
 
 syn keyword   rustInvalidBareKeyword crate
 
@@ -81,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
@@ -103,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/try2/src/liballoc/lib.rs

@@ -70,6 +70,7 @@
 
 #![no_std]
 #![feature(phase, unsafe_destructor)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)]
 extern crate core;

branches/try2/src/libarena/lib.rs

@@ -30,6 +30,7 @@
 
 #![feature(unsafe_destructor)]
 #![allow(missing_doc)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 use std::cell::{Cell, RefCell};
 use std::cmp;

branches/try2/src/libcollections/lib.rs

@@ -24,6 +24,7 @@
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
 #![feature(unsafe_destructor)]
 #![no_std]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;

branches/try2/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/try2/src/libcore/lib.rs

@@ -57,6 +57,7 @@
 #![no_std]
 #![feature(globs, macro_rules, managed_boxes, phase, simd, unsafe_destructor)]
 #![deny(missing_doc)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[cfg(test)] extern crate realcore = "core";
 #[cfg(test)] extern crate libc;

branches/try2/src/libnative/lib.rs

@@ -54,12 +54,15 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![deny(unused_result, unused_must_use)]
-#![allow(non_camel_case_types, deprecated)]
+#![allow(non_camel_case_types)]
+#![allow(deprecated)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
+#![feature(default_type_params)]
 
 // NB this crate explicitly does *not* allow glob imports, please seriously
 //    consider whether they're needed before adding that feature here (the
 //    answer is that you don't need them)
-#![feature(macro_rules, unsafe_destructor, default_type_params)]
+#![feature(macro_rules, unsafe_destructor)]
 
 extern crate alloc;
 extern crate libc;

branches/try2/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/try2/src/librustc/lib.rs

@@ -29,6 +29,7 @@ This API is completely unstable and subject to change.
       html_root_url = "http://doc.rust-lang.org/")]
 
 #![allow(deprecated)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 #![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
 #![feature(default_type_params, phase, unsafe_destructor)]