---

yaml
---
r: 49909
b: refs/heads/auto
c: 9c40ebb
h: refs/heads/master
i:
  49907: 4b8ff3a
v: v3

Author: tedhorst

[refs]

@@ -14,5 +14,5 @@ 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: becad9bb07423ed4d0d8b192cce83de99b535e86
+refs/heads/auto: 9c40ebbb9a70b14a87d09bcd873c9c788627b3dc
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/src/libcore/container.rs

@@ -35,9 +35,6 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: &fn(&V) -> bool);
 
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
-
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V>;
 

branches/auto/src/libcore/hashmap.rs

@@ -324,19 +324,6 @@ pub mod linear {
             self.each(|&(_, v)| blk(v))
         }
 
-        /// Iterate over the map and mutate the contained values
-        fn mutate_values(&mut self, blk: &fn(&'self K,
-                              &'self mut V) -> bool) {
-            for uint::range(0, self.buckets.len()) |i| {
-                match self.buckets[i] {
-                  Some(Bucket{key: ref key, value: ref mut value, _}) => {
-                    if !blk(key, value) { return }
-                  }
-                  None => ()
-                }
-            }
-        }
-
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
             match self.bucket_for_key(k) {

branches/auto/src/libcore/trie.rs

@@ -81,16 +81,11 @@ impl<T> Map<uint, T> for TrieMap<T> {
 
     /// Visit all values in order
     #[inline(always)]
-    pure fn each_value(&self, f: &fn(&T) -> bool) {
+    pure fn each_value(&self,
+                       f: &fn(&T) -> bool) {
         self.each(|&(_, v)| f(v))
     }
 
-    /// Iterate over the map and mutate the contained values
-    #[inline(always)]
-    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) {
-        self.root.mutate_values(f);
-    }
-
     /// Return the value corresponding to the key in the map
     #[inline(hint)]
     pure fn find(&self, key: &uint) -> Option<&self/T> {
@@ -155,6 +150,11 @@ impl<T> TrieMap<T> {
     pure fn each_value_reverse(&self, f: &fn(&T) -> bool) {
         self.each_reverse(|&(_, v)| f(v))
     }
+
+    /// Iterate over the map and mutate the contained values
+    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) {
+        self.root.mutate_values(f);
+    }
 }
 
 pub struct TrieSet {
@@ -248,13 +248,13 @@ impl<T> TrieNode<T> {
         true
     }
 
-    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
+    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) -> bool {
         for vec::each_mut(self.children) |child| {
             match *child {
                 Internal(ref mut x) => if !x.mutate_values(f) {
                     return false
                 },
-                External(k, ref mut v) => if !f(&k, v) { return false },
+                External(k, ref mut v) => if !f(k, v) { return false },
                 Nothing => ()
             }
         }
@@ -269,8 +269,8 @@ pure fn chunk(n: uint, idx: uint) -> uint {
     (n >> (SHIFT * real_idx)) & MASK
 }
 
-fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
-             idx: uint) -> bool {
+fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
+                   value: T, idx: uint) -> bool {
     let mut tmp = Nothing;
     tmp <-> *child;
     let mut added = false;

branches/auto/src/librust/rust.rc

@@ -9,8 +9,8 @@
 // except according to those terms.
 
 // rust - central access to other rust tools
-// XXX: Make commands run and test emit proper file endings on winds
-// XXX: Make run only accept source that emits an executable
+// FIXME #2238 Make commands run and test emit proper file endings on winds
+// FIXME #2238 Make run only accept source that emits an executable
 
 #[deny(deprecated_self)];
 

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

@@ -867,7 +867,7 @@ pub fn in_lpad_scope_cx(bcx: block, f: &fn(+si: &mut scope_info)) {
     let mut bcx = bcx;
     loop {
         {
-            // XXX: Borrow check bug workaround.
+            // FIXME #4280: Borrow check bug workaround.
             let kind: &mut block_kind = &mut *bcx.kind;
             match *kind {
                 block_scope(ref mut inf) => {
@@ -1272,7 +1272,7 @@ pub fn cleanup_and_leave(bcx: block,
         }
 
         {
-            // XXX: Borrow check bug workaround.
+            // FIXME #4280: Borrow check bug workaround.
             let kind: &mut block_kind = &mut *cur.kind;
             match *kind {
               block_scope(ref mut inf) if !inf.cleanups.is_empty() => {
@@ -1850,8 +1850,7 @@ pub fn trans_enum_variant(ccx: @CrateContext,
     };
     let fcx = new_fn_ctxt_w_id(ccx, ~[], llfndecl, variant.node.id, None,
                                param_substs, None);
-    // XXX: Bad copy.
-    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, copy fn_args);
+    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args);
     let ty_param_substs = match param_substs {
       Some(ref substs) => /*bad*/copy substs.tys,
       None => ~[]

branches/auto/src/libstd/smallintmap.rs

@@ -85,17 +85,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         self.each(|&(_, v)| blk(v))
     }
 
-    /// Visit all key-value pairs in order
-    fn mutate_values(&mut self, it: &fn(&uint, &'self mut V) -> bool) {
-        for uint::range(0, self.v.len()) |i| {
-            match self.v[i] {
-              Some(ref mut elt) => if !it(&i, elt) { break },
-              None => ()
-            }
-        }
-    }
-
-    /// Iterate over the map and mutate the contained values
+    /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &uint) -> Option<&self/V> {
         if *key < self.v.len() {
             match self.v[*key] {

branches/auto/src/libstd/treemap.rs

@@ -134,11 +134,6 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         self.each(|&(_, v)| f(v))
     }
 
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&'self K, &'self mut V) -> bool) {
-        mutate_values(&mut self.root, f);
-    }
-
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V> {
         let mut current: &self/Option<~TreeNode<K, V>> = &self.root;
@@ -563,20 +558,6 @@ pure fn each_reverse<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
     }
 }
 
-fn mutate_values<K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
-                                 f: &fn(&'r K, &'r mut V) -> bool) -> bool {
-    match *node {
-      Some(~TreeNode{key: ref key, value: ref mut value, left: ref mut left,
-                     right: ref mut right, _}) => {
-        if !mutate_values(left, f) { return false }
-        if !f(key, value) { return false }
-        if !mutate_values(right, f) { return false }
-      }
-      None => return false
-    }
-    true
-}
-
 // Remove left horizontal link by rotating right
 fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     if node.left.map_default(false, |x| x.level == node.level) {

branches/auto/src/test/bench/shootout-threadring.rs

@@ -0,0 +1,74 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Based on threadring.erlang by Jira Isa
+
+fn start(n_tasks: int, token: int) {
+    let mut (p, ch1) = comm::stream();
+    ch1.send(token);
+    //  XXX could not get this to work with a range closure
+    let mut i = 2;
+    while i <= n_tasks {
+        let (next_p, ch) = comm::stream();
+        let imm_i = i;
+        let imm_p = p;
+        do task::spawn {
+            roundtrip(imm_i, n_tasks, &imm_p, &ch);
+        };
+        p = next_p;
+        i += 1;
+    }
+    let imm_p = p;
+    let imm_ch = ch1;
+    do task::spawn {
+        roundtrip(1, n_tasks, &imm_p, &imm_ch);
+    }
+}
+
+fn roundtrip(id: int, n_tasks: int, p: &comm::Port<int>, ch: &comm::Chan<int>) {
+    while (true) {
+        match p.recv() {
+          1 => {
+            io::println(fmt!("%d\n", id));
+            return;
+          }
+          token => {
+            debug!("thread: %d   got token: %d", id, token);
+            ch.send(token - 1);
+            if token <= n_tasks {
+                return;
+            }
+          }
+        }
+    }
+}
+
+fn main() {
+    let args = if os::getenv(~"RUST_BENCH").is_some() {
+        ~[~"", ~"2000000", ~"503"]
+    }
+    else {
+        os::args()
+    };
+    let token = if args.len() > 1u {
+        int::from_str(args[1]).get()
+    }
+    else {
+        1000
+    };
+    let n_tasks = if args.len() > 2u {
+        int::from_str(args[2]).get()
+    }
+    else {
+        503
+    };
+    start(n_tasks, token);
+
+}

branches/auto/src/test/run-pass/class-impl-very-parameterized-trait.rs

@@ -81,10 +81,6 @@ impl<T> Map<int, T> for cat<T> {
         for self.each |&(_, v)| { if !f(v) { break; } loop;};
     }
 
-    fn mutate_values(&mut self, f: &fn(&int, &mut T) -> bool) {
-        fail!(~"nope")
-    }
-
     fn insert(&mut self, k: int, _: T) -> bool {
         self.meows += k;
         true