---

yaml
---
r: 42967
b: refs/heads/try
c: 5281709
h: refs/heads/master
i:
  42965: f8cfca5
  42963: ac47699
  42959: b70071c
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: 2f46b763da2c098913884f101b6d71d69af41b49
+refs/heads/try: 52817092a937738bc437800018cf202bb826d712
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

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/pipes.rs

@@ -143,9 +143,14 @@ pub fn BufferHeader() -> BufferHeader {
 // This is for protocols to associate extra data to thread around.
 #[doc(hidden)]
 #[cfg(stage0)]
-type Buffer<T> = { header: BufferHeader, data: T };
+type Buffer<T: Owned> = {
+    header: BufferHeader,
+    data: T,
+};
+#[doc(hidden)]
 #[cfg(stage1)]
 #[cfg(stage2)]
+#[cfg(stage3)]
 pub struct Buffer<T> {
     header: BufferHeader,
     data: T,
@@ -242,6 +247,7 @@ pub fn mk_packet<T: Owned>() -> Packet<T> {
         payload: None,
     }
 }
+
 #[doc(hidden)]
 #[cfg(stage0)]
 fn unibuffer<T: Owned>() -> ~Buffer<Packet<T>> {
@@ -261,6 +267,7 @@ fn unibuffer<T: Owned>() -> ~Buffer<Packet<T>> {
 #[doc(hidden)]
 #[cfg(stage1)]
 #[cfg(stage2)]
+#[cfg(stage3)]
 fn unibuffer<T>() -> ~Buffer<Packet<T>> {
     let b = ~Buffer {
         header: BufferHeader(),

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/librustc/back/link.rs

@@ -596,7 +596,7 @@ pub fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
 }
 
 pub fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> @str {
-    match ccx.type_hashcodes.find(t) {
+    match ccx.type_hashcodes.find(&t) {
       Some(h) => h,
       None => {
         let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);

branches/try/src/librustc/driver/driver.rs

@@ -538,7 +538,7 @@ pub fn build_session_options(+binary: ~str,
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
             let lint_name = str::replace(*lint_name, ~"-", ~"_");
-            match lint_dict.find(/*bad*/ copy lint_name) {
+            match lint_dict.find(&lint_name) {
               None => {
                 early_error(demitter, fmt!("unknown %s flag: %s",
                                            level_name, lint_name));

branches/try/src/librustc/lib/llvm.rs

@@ -1331,11 +1331,11 @@ pub fn associate_type(tn: type_names, s: @str, t: TypeRef) {
 }
 
 pub fn type_has_name(tn: type_names, t: TypeRef) -> Option<@str> {
-    return tn.type_names.find(t);
+    return tn.type_names.find(&t);
 }
 
 pub fn name_has_type(tn: type_names, s: @str) -> Option<TypeRef> {
-    return tn.named_types.find(s);
+    return tn.named_types.find(&s);
 }
 
 pub fn mk_type_names() -> type_names {

branches/try/src/librustc/metadata/cstore.rs

@@ -74,7 +74,7 @@ pub fn mk_cstore(intr: @ident_interner) -> CStore {
 
 pub fn get_crate_data(cstore: CStore, cnum: ast::crate_num)
                    -> crate_metadata {
-    return p(cstore).metas.get(cnum);
+    return p(cstore).metas.get(&cnum);
 }
 
 pub fn get_crate_hash(cstore: CStore, cnum: ast::crate_num) -> ~str {
@@ -139,7 +139,7 @@ pub fn add_use_stmt_cnum(cstore: CStore, use_id: ast::node_id,
 
 pub fn find_use_stmt_cnum(cstore: CStore,
                           use_id: ast::node_id) -> Option<ast::crate_num> {
-    p(cstore).use_crate_map.find(use_id)
+    p(cstore).use_crate_map.find(&use_id)
 }
 
 // returns hashes of crates directly used by this crate. Hashes are

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

@@ -1099,7 +1099,7 @@ pub fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id {
         return ast::def_id { crate: cdata.cnum, node: did.node };
     }
 
-    match cdata.cnum_map.find(did.crate) {
+    match cdata.cnum_map.find(&did.crate) {
       option::Some(n) => ast::def_id { crate: n, node: did.node },
       option::None => die!(~"didn't find a crate in the cnum_map")
     }

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

@@ -118,7 +118,7 @@ pub fn encode_def_id(ebml_w: writer::Encoder, id: def_id) {
 
 fn encode_region_param(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                        it: @ast::item) {
-    let opt_rp = ecx.tcx.region_paramd_items.find(it.id);
+    let opt_rp = ecx.tcx.region_paramd_items.find(&it.id);
     for opt_rp.each |rp| {
         do ebml_w.wr_tag(tag_region_param) {
             (*rp).encode(&ebml_w);
@@ -184,7 +184,7 @@ fn encode_ty_type_param_bounds(ebml_w: writer::Encoder, ecx: @encode_ctxt,
 fn encode_type_param_bounds(ebml_w: writer::Encoder, ecx: @encode_ctxt,
                             params: &[ty_param]) {
     let ty_param_bounds =
-        @params.map(|param| ecx.tcx.ty_param_bounds.get(param.id));
+        @params.map(|param| ecx.tcx.ty_param_bounds.get(&param.id));
     encode_ty_type_param_bounds(ebml_w, ecx, ty_param_bounds);
 }
 
@@ -224,7 +224,7 @@ fn encode_type(ecx: @encode_ctxt, ebml_w: writer::Encoder, typ: ty::t) {
 
 fn encode_symbol(ecx: @encode_ctxt, ebml_w: writer::Encoder, id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    let sym = match ecx.item_symbols.find(id) {
+    let sym = match ecx.item_symbols.find(&id) {
       Some(ref x) => (/*bad*/copy *x),
       None => {
         ecx.diag.handler().bug(
@@ -238,7 +238,7 @@ fn encode_symbol(ecx: @encode_ctxt, ebml_w: writer::Encoder, id: node_id) {
 fn encode_discriminant(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                        id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(id)));
+    ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(&id)));
     ebml_w.end_tag();
 }
 
@@ -349,7 +349,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: writer::Encoder,
 
     // Encode the reexports of this module.
     debug!("(encoding info for module) encoding reexports for %d", id);
-    match ecx.reexports2.find(id) {
+    match ecx.reexports2.find(&id) {
         Some(ref exports) => {
             debug!("(encoding info for module) found reexports for %d", id);
             for (*exports).each |exp| {
@@ -813,7 +813,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Encoder,
             encode_name(ecx, ebml_w, ty_m.ident);
             encode_family(ebml_w,
                           purity_static_method_family(ty_m.purity));
-            let polyty = ecx.tcx.tcache.get(local_def(ty_m.id));
+            let polyty = ecx.tcx.tcache.get(&local_def(ty_m.id));
             encode_ty_type_param_bounds(ebml_w, ecx, polyty.bounds);
             encode_type(ecx, ebml_w, polyty.ty);
             let mut m_path = vec::append(~[], path); // :-(
@@ -881,7 +881,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: writer::Encoder,
             let ebml_w = copy ebml_w;
             |i, cx, v| {
                 visit::visit_item(i, cx, v);
-                match ecx.tcx.items.get(i.id) {
+                match ecx.tcx.items.get(&i.id) {
                     ast_map::node_item(_, pt) => {
                         encode_info_for_item(ecx, ebml_w, i,
                                              index, *pt);
@@ -894,7 +894,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: writer::Encoder,
             let ebml_w = copy ebml_w;
             |ni, cx, v| {
                 visit::visit_foreign_item(ni, cx, v);
-                match ecx.tcx.items.get(ni.id) {
+                match ecx.tcx.items.get(&ni.id) {
                     ast_map::node_foreign_item(_, abi, pt) => {
                         encode_info_for_foreign_item(ecx, ebml_w, ni,
                                                      index, /*bad*/copy *pt,

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

@@ -329,7 +329,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let len = parse_hex(st);
         assert (next(st) == '#');
         let key = creader_cache_key { cnum: st.crate, pos: pos, len: len };
-        match st.tcx.rcache.find(key) {
+        match st.tcx.rcache.find(&key) {
           Some(tt) => return tt,
           None => {
             let ps = @{pos: pos ,.. copy *st};

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

@@ -56,7 +56,7 @@ fn cx_uses_abbrevs(cx: @ctxt) -> bool {
 pub fn enc_ty(w: io::Writer, cx: @ctxt, t: ty::t) {
     match cx.abbrevs {
       ac_no_abbrevs => {
-        let result_str = match cx.tcx.short_names_cache.find(t) {
+        let result_str = match cx.tcx.short_names_cache.find(&t) {
             Some(s) => /*bad*/copy *s,
             None => {
                 let s = do io::with_str_writer |wr| {
@@ -69,7 +69,7 @@ pub fn enc_ty(w: io::Writer, cx: @ctxt, t: ty::t) {
         w.write_str(result_str);
       }
       ac_use_abbrevs(abbrevs) => {
-        match abbrevs.find(t) {
+        match abbrevs.find(&t) {
           Some(a) => { w.write_str(*a.s); return; }
           None => {
             let pos = w.tell();