---

yaml
---
r: 42975
b: refs/heads/try
c: e72c917
h: refs/heads/master
i:
  42973: 96a7b36
  42971: 8e77cc3
  42967: 0e9891e
  42959: b70071c
  42943: cede17b
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: abd29e5eadb46ec7d7126fa0438c1c52c4ace00f
+refs/heads/try: e72c917f7120eef8f7b2e18537a8b9589fb21b10
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/configure

@@ -515,7 +515,7 @@ then
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 4.0* | 4.1*)
+        (3.0svn | 3.0 | 3.1* | 3.2* | 4.0* | 4.1* | 4.2*)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

branches/try/doc/rust.md

@@ -1719,15 +1719,12 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
-The keyword `mut` can be written after the opening bracket to
-indicate that the elements of the resulting vector may be mutated.
-When no mutability is specified, the vector is immutable.
 
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
 [0, ..128];             // vector with 128 zeros
-[mut 0u8, 0u8, 0u8, 0u8];
+[0u8, 0u8, 0u8, 0u8];
 ~~~~
 
 ### Index expressions
@@ -1749,7 +1746,6 @@ task in a _failing state_.
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
-([mut 'x', 'y'])[1] = 'z';
 (["a", "b"])[10]; // fails
 
 # }
@@ -1912,8 +1908,8 @@ No allocation or destruction is entailed.
 An example of three different swap expressions:
 
 ~~~~~~~~
-# let mut x = &[mut 0];
-# let mut a = &[mut 0];
+# let mut x = &mut [0];
+# let mut a = &mut [0];
 # let i = 0;
 # let y = {mut z: 0};
 # let b = {mut c: 0};
@@ -2008,11 +2004,11 @@ the unary copy operator is typically only used to cause an argument to a functio
 An example of a copy expression:
 
 ~~~~
-fn mutate(vec: ~[mut int]) {
+fn mutate(mut vec: ~[int]) {
    vec[0] = 10;
 }
 
-let v = ~[mut 1,2,3];
+let v = ~[1,2,3];
 
 mutate(copy v);   // Pass a copy
 

branches/try/doc/tutorial.md

@@ -1795,7 +1795,7 @@ Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
-    elements: ~[mut T]
+    elements: ~[T]
 }
 
 enum Option<T> {

branches/try/src/libcargo/cargo.rc

@@ -731,7 +731,7 @@ pub fn configure(opts: Options) -> Cargo {
     need_dir(&c.bindir);
 
     for sources.each_key_ref |&k| {
-        let mut s = sources.get(k);
+        let mut s = sources.get(&k);
         load_source_packages(&c, s);
         sources.insert(k, s);
     }
@@ -981,7 +981,7 @@ pub fn install_named(c: &mut Cargo, wd: &Path, name: ~str) {
 
 pub fn install_uuid_specific(c: &mut Cargo, wd: &Path, src: ~str,
                              uuid: ~str) {
-    match c.sources.find(src) {
+    match c.sources.find(&src) {
         Some(s) => {
             for s.packages.each |p| {
                 if p.uuid == uuid {
@@ -997,7 +997,7 @@ pub fn install_uuid_specific(c: &mut Cargo, wd: &Path, src: ~str,
 
 pub fn install_named_specific(c: &mut Cargo, wd: &Path, src: ~str,
                               name: ~str) {
-    match c.sources.find(src) {
+    match c.sources.find(&src) {
         Some(s) => {
             for s.packages.each |p| {
                 if p.name == name {
@@ -1064,7 +1064,7 @@ pub fn cmd_uninstall(c: &Cargo) {
 }
 
 pub fn install_query(c: &mut Cargo, wd: &Path, target: ~str) {
-    match c.dep_cache.find(target) {
+    match c.dep_cache.find(&target) {
         Some(inst) => {
             if inst {
                 return;
@@ -1156,7 +1156,7 @@ pub fn cmd_install(c: &mut Cargo) {
 
 pub fn sync(c: &Cargo) {
     for c.sources.each_key_ref |&k| {
-        let mut s = c.sources.get(k);
+        let mut s = c.sources.get(&k);
         sync_one(c, s);
         c.sources.insert(k, s);
     }
@@ -1558,7 +1558,7 @@ pub fn cmd_list(c: &Cargo) {
             if !valid_pkg_name(*name) {
                 error(fmt!("'%s' is an invalid source name", *name));
             } else {
-                match c.sources.find(*name) {
+                match c.sources.find(name) {
                     Some(source) => {
                         print_source(source);
                     }
@@ -1754,7 +1754,7 @@ pub fn cmd_sources(c: &Cargo) {
                 return;
             }
 
-            match c.sources.find(name) {
+            match c.sources.find(&name) {
                 Some(source) => {
                     let old = copy source.url;
                     let method = assume_source_method(url);
@@ -1785,7 +1785,7 @@ pub fn cmd_sources(c: &Cargo) {
                 return;
             }
 
-            match c.sources.find(name) {
+            match c.sources.find(&name) {
                 Some(source) => {
                     let old = copy source.method;
 
@@ -1823,7 +1823,7 @@ pub fn cmd_sources(c: &Cargo) {
                 return;
             }
 
-            match c.sources.find(name) {
+            match c.sources.find(&name) {
                 Some(source) => {
                     c.sources.remove(&name);
                     c.sources.insert(newn, source);

branches/try/src/libcore/either.rs

@@ -150,6 +150,23 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
 }
 
 impl<T, U> Either<T, U> {
+    #[inline(always)]
+    fn either<V>(&self, f_left: fn(&T) -> V, f_right: fn(&U) -> V) -> V {
+        either(f_left, f_right, self)
+    }
+
+    #[inline(always)]
+    fn flip(self) -> Either<U, T> { flip(self) }
+
+    #[inline(always)]
+    fn to_result(self) -> Result<U, T> { to_result(self) }
+
+    #[inline(always)]
+    fn is_left(&self) -> bool { is_left(self) }
+
+    #[inline(always)]
+    fn is_right(&self) -> bool { is_right(self) }
+
     #[inline(always)]
     fn unwrap_left(self) -> T { unwrap_left(self) }
 

branches/try/src/libcore/io.rs

@@ -490,25 +490,25 @@ pub fn FILERes(f: *libc::FILE) -> FILERes {
     }
 }
 
-pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader {
+pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
     if cleanup {
-        Wrapper { base: f, cleanup: FILERes(f) } as Reader
+        @Wrapper { base: f, cleanup: FILERes(f) } as @Reader
     } else {
-        f as Reader
+        @f as @Reader
     }
 }
 
 // FIXME (#2004): this should either be an trait-less impl, a set of
 // top-level functions that take a reader, or a set of default methods on
 // reader (which can then be called reader)
 
-pub fn stdin() -> Reader {
+pub fn stdin() -> @Reader {
     unsafe {
-        rustrt::rust_get_stdin() as Reader
+        rustrt::rust_get_stdin() as @Reader
     }
 }
 
-pub fn file_reader(path: &Path) -> Result<Reader, ~str> {
+pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
     unsafe {
         let f = os::as_c_charp(path.to_str(), |pathbuf| {
             os::as_c_charp("r", |modebuf|
@@ -555,11 +555,11 @@ impl BytesReader: Reader {
     fn tell(&self) -> uint { self.pos }
 }
 
-pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(Reader) -> t) -> t {
-    f(BytesReader { bytes: bytes, pos: 0u } as Reader)
+pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(@Reader) -> t) -> t {
+    f(@BytesReader { bytes: bytes, pos: 0u } as @Reader)
 }
 
-pub pure fn with_str_reader<T>(s: &str, f: fn(Reader) -> T) -> T {
+pub pure fn with_str_reader<T>(s: &str, f: fn(@Reader) -> T) -> T {
     str::byte_slice(s, |bytes| with_bytes_reader(bytes, f))
 }
 

branches/try/src/libcore/num/f32.rs

@@ -439,7 +439,7 @@ pub pure fn to_str_digits(num: f32, dig: uint) -> ~str {
 
 impl f32: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str() -> ~str { to_str_digits(self, 8) }
+    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
 }
 
 impl f32: num::ToStrRadix {

branches/try/src/libcore/num/f64.rs

@@ -463,7 +463,7 @@ pub pure fn to_str_digits(num: f64, dig: uint) -> ~str {
 
 impl f64: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str() -> ~str { to_str_digits(self, 8) }
+    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
 }
 
 impl f64: num::ToStrRadix {

branches/try/src/libcore/num/float.rs

@@ -206,7 +206,7 @@ pub pure fn to_str_digits(num: float, digits: uint) -> ~str {
 
 impl float: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str() -> ~str { to_str_digits(self, 8) }
+    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
 }
 
 impl float: num::ToStrRadix {

branches/try/src/libcore/num/int-template.rs

@@ -287,8 +287,8 @@ pub pure fn str(i: T) -> ~str { to_str(i) }
 
 impl T : ToStr {
     #[inline(always)]
-    pure fn to_str() -> ~str {
-        to_str(self)
+    pure fn to_str(&self) -> ~str {
+        to_str(*self)
     }
 }
 

branches/try/src/libcore/num/uint-template.rs

@@ -249,8 +249,8 @@ pub pure fn str(i: T) -> ~str { to_str(i) }
 
 impl T : ToStr {
     #[inline(always)]
-    pure fn to_str() -> ~str {
-        to_str(self)
+    pure fn to_str(&self) -> ~str {
+        to_str(*self)
     }
 }
 

branches/try/src/libcore/path.rs

@@ -368,7 +368,7 @@ impl Path {
 }
 
 impl PosixPath : ToStr {
-    pure fn to_str() -> ~str {
+    pure fn to_str(&self) -> ~str {
         let mut s = ~"";
         if self.is_absolute {
             s += "/";
@@ -531,7 +531,7 @@ impl PosixPath : GenericPath {
 
 
 impl WindowsPath : ToStr {
-    pure fn to_str() -> ~str {
+    pure fn to_str(&self) -> ~str {
         let mut s = ~"";
         match self.host {
           Some(ref h) => { s += "\\\\"; s += *h; }

branches/try/src/libcore/prelude.rs

@@ -12,40 +12,37 @@
 
 /* Reexported core operators */
 
+pub use either::{Either, Left, Right};
 pub use kinds::{Const, Copy, Owned, Durable};
-pub use ops::{Drop};
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
+pub use ops::{Drop};
 pub use ops::{Shl, Shr, Index};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};
 
 /* Reexported types and traits */
 
-pub use path::Path;
+pub use clone::Clone;
+pub use cmp::{Eq, Ord};
+pub use container::{Container, Mutable, Map, Set};
+pub use hash::Hash;
+pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use num::Num;
 pub use path::GenericPath;
-pub use path::WindowsPath;
+pub use path::Path;
 pub use path::PosixPath;
-
-pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
+pub use path::WindowsPath;
+pub use pipes::{GenericChan, GenericPort};
+pub use ptr::Ptr;
 pub use str::{StrSlice, Trimmable};
-pub use container::{Container, Mutable};
+pub use to_bytes::IterBytes;
+pub use to_str::ToStr;
+pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
 pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
-pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
-pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
-pub use container::{Container, Mutable, Map, Set};
-pub use pipes::{GenericChan, GenericPort};
-
-pub use num::Num;
-pub use ptr::Ptr;
-pub use to_str::ToStr;
-pub use clone::Clone;
-
-pub use cmp::{Eq, Ord};
-pub use hash::Hash;
-pub use to_bytes::IterBytes;
 
 /* Reexported modules */
 

branches/try/src/libcore/private.rs

@@ -486,7 +486,7 @@ pub mod tests {
         res.recv();
     }
 
-    #[test] #[should_fail] #[ignore(cfg(windows))]
+    #[test] #[should_fail] #[ignore(reason = "random red")]
     pub fn exclusive_unwrap_conflict() {
         let x = exclusive(~~"hello");
         let x2 = ~mut Some(x.clone());