---

yaml
---
r: 42731
b: refs/heads/try
c: a72aeef
h: refs/heads/master
i:
  42729: a3741d4
  42727: 89ef194
v: v3

Author: brson

[refs]

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

branches/try/src/libcore/io.rs

@@ -185,13 +185,13 @@ impl<T: Reader> T : ReaderUtil {
     }
 
     fn read_line(&self) -> ~str {
-        let mut line = ~"";
+        let mut bytes = ~[];
         loop {
             let ch = self.read_byte();
             if ch == -1 || ch == 10 { break; }
-            str::push_char(&mut line, ch as char);
+            bytes.push(ch as u8);
         }
-        line
+        str::from_bytes(bytes)
     }
 
     fn read_chars(&self, n: uint) -> ~[char] {
@@ -1221,6 +1221,14 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_read_line_utf8() {
+        do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
+            let line = inp.read_line();
+            assert line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤";
+        }
+    }
+
     #[test]
     fn test_readchars_wide() {
         let wide_test = ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤";

branches/try/src/libstd/cmp.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #[forbid(deprecated_mode)];
-//! Additional general-purpose comparison functionality.
+/// Additional general-purpose comparison functionality.
 
 use core::f32;
 use core::f64;
@@ -18,49 +18,31 @@ use core::float;
 const fuzzy_epsilon: float = 1.0e-6;
 
 pub trait FuzzyEq {
-    pure fn fuzzy_eq(&self, other: &self) -> bool;
-    pure fn fuzzy_eq_eps(&self, other: &self, epsilon: &self) -> bool;
+    pure fn fuzzy_eq(other: &self) -> bool;
 }
 
 impl float: FuzzyEq {
-    pure fn fuzzy_eq(&self, other: &float) -> bool {
-        float::abs(*self - *other) < fuzzy_epsilon
-    }
-
-    pure fn fuzzy_eq_eps(&self, other: &float, epsilon: &float) -> bool {
-        float::abs(*self - *other) < *epsilon
+    pure fn fuzzy_eq(other: &float) -> bool {
+        return float::abs(self - *other) < fuzzy_epsilon;
     }
 }
 
 impl f32: FuzzyEq {
-    pure fn fuzzy_eq(&self, other: &f32) -> bool {
-        f32::abs(*self - *other) < (fuzzy_epsilon as f32)
-    }
-
-    pure fn fuzzy_eq_eps(&self, other: &f32, epsilon: &f32) -> bool {
-        f32::abs(*self - *other) < *epsilon
+    pure fn fuzzy_eq(other: &f32) -> bool {
+        return f32::abs(self - *other) < (fuzzy_epsilon as f32);
     }
 }
 
 impl f64: FuzzyEq {
-    pure fn fuzzy_eq(&self, other: &f64) -> bool {
-        f64::abs(*self - *other) < (fuzzy_epsilon as f64)
-    }
-
-    pure fn fuzzy_eq_eps(&self, other: &f64, epsilon: &f64) -> bool {
-        f64::abs(*self - *other) < *epsilon
+    pure fn fuzzy_eq(other: &f64) -> bool {
+        return f64::abs(self - *other) < (fuzzy_epsilon as f64);
     }
 }
 
 #[test]
 fn test_fuzzy_equals() {
-    assert (&1.0).fuzzy_eq(&1.0);
-    assert (&1.0f32).fuzzy_eq(&1.0f32);
-    assert (&1.0f64).fuzzy_eq(&1.0f64);
+    assert ((&1.0).fuzzy_eq(&1.0));
+    assert ((&1.0f32).fuzzy_eq(&1.0f32));
+    assert ((&1.0f64).fuzzy_eq(&1.0f64));
 }
 
-#[test]
-fn test_fuzzy_eq_eps() {
-    assert (&1.2).fuzzy_eq_eps(&0.9, &0.5);
-    assert !(&1.5).fuzzy_eq_eps(&0.9, &0.5);
-}

branches/try/src/libstd/priority_queue.rs

@@ -76,8 +76,7 @@ impl <T: Ord> PriorityQueue<T> {
     }
 
     /// Optimized version of a push followed by a pop
-    fn push_pop(&mut self, item: T) -> T {
-        let mut item = item;
+    fn push_pop(&mut self, mut item: T) -> T {
         if !self.is_empty() && self.data[0] > item {
             item <-> self.data[0];
             self.siftdown(0);
@@ -86,8 +85,7 @@ impl <T: Ord> PriorityQueue<T> {
     }
 
     /// Optimized version of a pop followed by a push - fails if empty
-    fn replace(&mut self, item: T) -> T {
-        let mut item = item;
+    fn replace(&mut self, mut item: T) -> T {
         item <-> self.data[0];
         self.siftdown(0);
         item
@@ -129,9 +127,8 @@ impl <T: Ord> PriorityQueue<T> {
     // vector over the junk element.  This reduces the constant factor
     // compared to using swaps, which involves twice as many moves.
 
-    priv fn siftup(&mut self, start: uint, pos: uint) {
+    priv fn siftup(&mut self, start: uint, mut pos: uint) {
         unsafe {
-            let mut pos = pos;
             let new = move *addr_of(&self.data[pos]);
 
             while pos > start {
@@ -149,9 +146,8 @@ impl <T: Ord> PriorityQueue<T> {
         }
     }
 
-    priv fn siftdown_range(&mut self, pos: uint, end: uint) {
+    priv fn siftdown_range(&mut self, mut pos: uint, end: uint) {
         unsafe {
-            let mut pos = pos;
             let start = pos;
             let new = move *addr_of(&self.data[pos]);
 

branches/try/src/libstd/treemap.rs

@@ -572,9 +572,8 @@ pure fn each_reverse<K: Ord, V>(node: &Option<~TreeNode<K, V>>,
 }
 
 // Remove left horizontal link by rotating right
-fn skew<K: Ord, V>(node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
+fn skew<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.left.map_default(false, |x| x.level == node.level) {
-        let mut node = node;
         let mut save = node.left.swap_unwrap();
         node.left <-> save.right; // save.right now None
         save.right = Some(node);
@@ -586,10 +585,9 @@ fn skew<K: Ord, V>(node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
 
 // Remove dual horizontal link by rotating left and increasing level of
 // the parent
-fn split<K: Ord, V>(node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
+fn split<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.right.map_default(false,
       |x| x.right.map_default(false, |y| y.level == node.level)) {
-        let mut node = node;
         let mut save = node.right.swap_unwrap();
         node.right <-> save.left; // save.left now None
         save.left = Some(node);
@@ -628,8 +626,7 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
     fn heir_swap<K: Ord, V>(node: &mut TreeNode<K, V>,
                             child: &mut Option<~TreeNode<K, V>>) {
         // *could* be done without recursion, but it won't borrow check
-        do child.mutate |child| {
-            let mut child = child;
+        do child.mutate |mut child| {
             if child.right.is_some() {
                 heir_swap(&mut *node, &mut child.right);
             } else {
@@ -682,15 +679,13 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
             save.level -= 1;
 
             if right_level > save.level {
-                do save.right.mutate |x| {
-                    let mut x = x; x.level = save.level; x
-                }
+                do save.right.mutate |mut x| { x.level = save.level; x }
             }
 
             save = skew(save);
 
-            do save.right.mutate |right| {
-                let mut right = skew(right);
+            do save.right.mutate |mut right| {
+                right = skew(right);
                 right.right.mutate(skew);
                 right
             }