---

yaml
---
r: 149071
b: refs/heads/try2
c: 47ab5d2
h: refs/heads/master
i:
  149069: 6a84e74
  149067: 73ca042
  149063: c071740
  149055: 9e7ff93
v: v3

Author: bors

[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: 06a0c21c91b161781ee1aced0f2a9aed84cb4646
+refs/heads/try2: 47ab5d2d42aaf9e04afe6cc5aa84446e523d83ff
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -126,9 +126,9 @@ ifdef TRACE
 endif
 ifdef CFG_DISABLE_RPATH
 # NOTE: make this CFG_RUSTC_FLAGS after stage0 snapshot
-RUSTFLAGS_STAGE1 += --no-rpath
-RUSTFLAGS_STAGE2 += --no-rpath
-RUSTFLAGS_STAGE3 += --no-rpath
+RUSTFLAGS_STAGE1 += -C no-rpath
+RUSTFLAGS_STAGE2 += -C no-rpath
+RUSTFLAGS_STAGE3 += -C no-rpath
 endif
 
 # The executables crated during this compilation process have no need to include

branches/try2/src/libarena/lib.rs

@@ -40,7 +40,6 @@ use std::rc::Rc;
 use std::rt::global_heap;
 use std::unstable::intrinsics::{TyDesc, get_tydesc};
 use std::unstable::intrinsics;
-use std::util;
 use std::vec;
 
 // The way arena uses arrays is really deeply awful. The arrays are
@@ -404,7 +403,7 @@ impl TypedArenaChunk {
         }
 
         // Destroy the next chunk.
-        let next_opt = util::replace(&mut self.next, None);
+        let next_opt = mem::replace(&mut self.next, None);
         match next_opt {
             None => {}
             Some(mut next) => {

branches/try2/src/libcollections/dlist.rs

@@ -23,8 +23,8 @@
 // the reverse direction.
 
 use std::cast;
+use std::mem::{replace, swap};
 use std::ptr;
-use std::util;
 use std::iter::Rev;
 use std::iter;
 
@@ -102,7 +102,7 @@ impl<T> Rawlink<T> {
 
     /// Return the `Rawlink` and replace with `Rawlink::none()`
     fn take(&mut self) -> Rawlink<T> {
-        util::replace(self, Rawlink::none())
+        replace(self, Rawlink::none())
     }
 }
 
@@ -161,7 +161,7 @@ impl<T> DList<T> {
             Some(ref mut head) => {
                 new_head.prev = Rawlink::none();
                 head.prev = Rawlink::some(new_head);
-                util::swap(head, &mut new_head);
+                swap(head, &mut new_head);
                 head.next = Some(new_head);
             }
         }
@@ -319,7 +319,7 @@ impl<T> DList<T> {
     /// O(1)
     #[inline]
     pub fn prepend(&mut self, mut other: DList<T>) {
-        util::swap(self, &mut other);
+        swap(self, &mut other);
         self.append(other);
     }
 

branches/try2/src/libcollections/list.rs

@@ -63,6 +63,26 @@ pub fn find<T:Clone>(ls: @List<T>, f: |&T| -> bool) -> Option<T> {
     };
 }
 
+/**
+ * Returns true if a list contains an element that matches a given predicate
+ *
+ * Apply function `f` to each element of `ls`, starting from the first.
+ * When function `f` returns true then it also returns true. If `f` matches no
+ * elements then false is returned.
+ */
+pub fn any<T>(ls: @List<T>, f: |&T| -> bool) -> bool {
+    let mut ls = ls;
+    loop {
+        ls = match *ls {
+            Cons(ref hd, tl) => {
+                if f(hd) { return true; }
+                tl
+            }
+            Nil => return false
+        }
+    };
+}
+
 /// Returns true if a list contains an element with the given value
 pub fn has<T:Eq>(ls: @List<T>, elt: T) -> bool {
     let mut found = false;
@@ -222,6 +242,15 @@ mod tests {
         assert_eq!(list::find(empty, match_), option::None::<int>);
     }
 
+    #[test]
+    fn test_any() {
+        fn match_(i: &int) -> bool { return *i == 2; }
+        let l = from_vec([0, 1, 2]);
+        let empty = @list::Nil::<int>;
+        assert_eq!(list::any(l, match_), true);
+        assert_eq!(list::any(empty, match_), false);
+    }
+
     #[test]
     fn test_has() {
         let l = from_vec([5, 8, 6]);

branches/try2/src/libcollections/priority_queue.rs

@@ -13,8 +13,7 @@
 #[allow(missing_doc)];
 
 use std::clone::Clone;
-use std::mem::{move_val_init, init};
-use std::util::{replace, swap};
+use std::mem::{move_val_init, init, replace, swap};
 use std::vec;
 
 /// A priority queue implemented with a binary heap

branches/try2/src/libcollections/smallintmap.rs

@@ -16,7 +16,7 @@
 #[allow(missing_doc)];
 
 use std::iter::{Enumerate, FilterMap, Rev};
-use std::util::replace;
+use std::mem::replace;
 use std::vec;
 
 #[allow(missing_doc)]

branches/try2/src/libcollections/treemap.rs

@@ -12,9 +12,9 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
-use std::util::{swap, replace};
 use std::iter::{Peekable};
 use std::cmp::Ordering;
+use std::mem::{replace, swap};
 use std::ptr;
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};

branches/try2/src/libextra/num/bigint.rs

@@ -2592,7 +2592,8 @@ mod bigint_tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use std::{iter, util};
+    use std::iter;
+    use std::mem::replace;
     use std::num::{FromPrimitive, Zero, One};
     use extra::test::BenchHarness;
 
@@ -2609,7 +2610,7 @@ mod bench {
         let mut f1: BigUint = One::one();
         for _ in range(0, n) {
             let f2 = f0 + f1;
-            f0 = util::replace(&mut f1, f2);
+            f0 = replace(&mut f1, f2);
         }
         f0
     }

branches/try2/src/libextra/stats.rs

@@ -13,8 +13,8 @@
 use std::cmp;
 use std::hashmap;
 use std::io;
+use std::mem;
 use std::num;
-use std::util;
 
 // NB: this can probably be rewritten in terms of num::Num
 // to be less f64-specific.
@@ -178,7 +178,7 @@ impl<'a> Stats for &'a [f64] {
             for i in range(0, partials.len()) {
                 let mut y = partials[i];
                 if num::abs(x) < num::abs(y) {
-                    util::swap(&mut x, &mut y);
+                    mem::swap(&mut x, &mut y);
                 }
                 // Rounded `x+y` is stored in `hi` with round-off stored in
                 // `lo`. Together `hi+lo` are exactly equal to `x+y`.

branches/try2/src/libgreen/basic.rs

@@ -16,10 +16,10 @@
 //! loop if no other one is provided (and M:N scheduling is desired).
 
 use std::cast;
+use std::mem::replace;
 use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausableIdleCallback,
                     Callback};
 use std::unstable::sync::Exclusive;
-use std::util;
 
 /// This is the only exported function from this module.
 pub fn event_loop() -> ~EventLoop {
@@ -50,7 +50,7 @@ impl BasicLoop {
     /// Process everything in the work queue (continually)
     fn work(&mut self) {
         while self.work.len() > 0 {
-            for work in util::replace(&mut self.work, ~[]).move_iter() {
+            for work in replace(&mut self.work, ~[]).move_iter() {
                 work();
             }
         }
@@ -60,7 +60,7 @@ impl BasicLoop {
         let messages = unsafe {
             self.messages.with(|messages| {
                 if messages.len() > 0 {
-                    Some(util::replace(messages, ~[]))
+                    Some(replace(messages, ~[]))
                 } else {
                     None
                 }

branches/try2/src/libgreen/lib.rs

@@ -174,6 +174,7 @@
 // NB this does *not* include globs, please keep it that way.
 #[feature(macro_rules)];
 
+use std::mem::replace;
 use std::os;
 use std::rt::crate_map;
 use std::rt::rtio;
@@ -182,7 +183,6 @@ use std::rt;
 use std::sync::atomics::{SeqCst, AtomicUint, INIT_ATOMIC_UINT};
 use std::sync::deque;
 use std::task::TaskOpts;
-use std::util;
 use std::vec;
 use std::sync::arc::UnsafeArc;
 
@@ -457,10 +457,10 @@ impl SchedPool {
         }
 
         // Now that everyone's gone, tell everything to shut down.
-        for mut handle in util::replace(&mut self.handles, ~[]).move_iter() {
+        for mut handle in replace(&mut self.handles, ~[]).move_iter() {
             handle.send(Shutdown);
         }
-        for thread in util::replace(&mut self.threads, ~[]).move_iter() {
+        for thread in replace(&mut self.threads, ~[]).move_iter() {
             thread.join();
         }
     }

branches/try2/src/librustc/middle/privacy.rs

@@ -13,7 +13,7 @@
 //! which are available for use externally when compiled as a library.
 
 use std::hashmap::{HashSet, HashMap};
-use std::util;
+use std::mem::replace;
 
 use metadata::csearch;
 use middle::resolve;
@@ -679,7 +679,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
             return;
         }
 
-        let orig_curitem = util::replace(&mut self.curitem, item.id);
+        let orig_curitem = replace(&mut self.curitem, item.id);
         visit::walk_item(self, item, ());
         self.curitem = orig_curitem;
     }
@@ -861,7 +861,7 @@ impl Visitor<()> for SanePrivacyVisitor {
             self.check_sane_privacy(item);
         }
 
-        let orig_in_fn = util::replace(&mut self.in_fn, match item.node {
+        let orig_in_fn = replace(&mut self.in_fn, match item.node {
             ast::ItemMod(..) => false, // modules turn privacy back on
             _ => self.in_fn,           // otherwise we inherit
         });
@@ -872,7 +872,7 @@ impl Visitor<()> for SanePrivacyVisitor {
     fn visit_fn(&mut self, fk: &visit::FnKind, fd: &ast::FnDecl,
                 b: &ast::Block, s: Span, n: ast::NodeId, _: ()) {
         // This catches both functions and methods
-        let orig_in_fn = util::replace(&mut self.in_fn, true);
+        let orig_in_fn = replace(&mut self.in_fn, true);
         visit::walk_fn(self, fk, fd, b, s, n, ());
         self.in_fn = orig_in_fn;
     }

branches/try2/src/librustc/middle/resolve.rs

@@ -31,7 +31,7 @@ use syntax::visit::Visitor;
 use std::cell::{Cell, RefCell};
 use std::uint;
 use std::hashmap::{HashMap, HashSet};
-use std::util;
+use std::mem::replace;
 
 // Definition mapping
 pub type DefMap = @RefCell<HashMap<NodeId,Def>>;
@@ -4067,7 +4067,7 @@ impl Resolver {
                             new_trait_refs.push(def_id_of_def(*def));
                         }
                     }
-                    original_trait_refs = Some(util::replace(
+                    original_trait_refs = Some(replace(
                         &mut this.current_trait_refs,
                         Some(new_trait_refs)));
                 }

branches/try2/src/librustc/middle/trans/base.rs

@@ -1506,16 +1506,19 @@ pub fn trans_closure<'a>(ccx: @CrateContext,
     // emitting should be enabled.
     debuginfo::start_emitting_source_locations(&fcx);
 
+    let dest = match fcx.llretptr.get() {
+        Some(e) => {expr::SaveIn(e)}
+        None => {
+            assert!(type_is_zero_size(bcx.ccx(), block_ty))
+            expr::Ignore
+        }
+    };
+
     // This call to trans_block is the place where we bridge between
     // translation calls that don't have a return value (trans_crate,
     // trans_mod, trans_item, et cetera) and those that do
     // (trans_block, trans_expr, et cetera).
-    if body.expr.is_none() || type_is_zero_size(bcx.ccx(), block_ty) {
-        bcx = controlflow::trans_block(bcx, body, expr::Ignore);
-    } else {
-        let dest = expr::SaveIn(fcx.llretptr.get().unwrap());
-        bcx = controlflow::trans_block(bcx, body, dest);
-    }
+    bcx = controlflow::trans_block(bcx, body, dest);
 
     match fcx.llreturn.get() {
         Some(_) => {

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

@@ -74,7 +74,7 @@ pub fn trans_stmt<'a>(cx: &'a Block<'a>,
 
 pub fn trans_block<'a>(bcx: &'a Block<'a>,
                        b: &ast::Block,
-                       dest: expr::Dest)
+                       mut dest: expr::Dest)
                        -> &'a Block<'a> {
     let _icx = push_ctxt("trans_block");
     let fcx = bcx.fcx;
@@ -85,6 +85,14 @@ pub fn trans_block<'a>(bcx: &'a Block<'a>,
     for s in b.stmts.iter() {
         bcx = trans_stmt(bcx, *s);
     }
+
+    if dest != expr::Ignore {
+        let block_ty = node_id_type(bcx, b.id);
+        if b.expr.is_none() || type_is_zero_size(bcx.ccx(), block_ty) {
+            dest = expr::Ignore;
+        }
+    }
+
     match b.expr {
         Some(e) => {
             bcx = expr::trans_into(bcx, e, dest);

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -115,8 +115,8 @@ use util::ppaux::{UserString, Repr};
 
 use std::cell::{Cell, RefCell};
 use std::hashmap::HashMap;
+use std::mem::replace;
 use std::result;
-use std::util::replace;
 use std::vec;
 use syntax::abi::AbiSet;
 use syntax::ast::{Provided, Required};

branches/try2/src/librustdoc/fold.rs

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std;
 use clean::*;
 use std::iter::Extendable;
+use std::mem::{replace, swap};
 
 pub trait DocFolder {
     fn fold_item(&mut self, item: Item) -> Option<Item> {
@@ -19,7 +19,6 @@ pub trait DocFolder {
 
     /// don't override!
     fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
-        use std::util::swap;
         let Item { attrs, name, source, visibility, id, inner } = item;
         let inner = inner;
         let c = |x| self.fold_item(x);
@@ -92,7 +91,7 @@ pub trait DocFolder {
     }
 
     fn fold_crate(&mut self, mut c: Crate) -> Crate {
-        c.module = match std::util::replace(&mut c.module, None) {
+        c.module = match replace(&mut c.module, None) {
             Some(module) => self.fold_item(module), None => None
         };
         return c;