---

yaml
---
r: 125183
b: refs/heads/auto
c: c770007
h: refs/heads/master
i:
  125181: 7cd25cb
  125179: d3f134e
  125175: 758871a
  125167: 04f88ec
  125151: 6f8acf8
  125119: a2d2efc
  125055: 5c7a026
  124927: f1baf7a
v: v3

Author: Randati

[refs]

@@ -13,7 +13,7 @@ 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: 74db69995a87424098ec78aeae0964b615ba43e6
+refs/heads/auto: c7700077a103303a7134dcbbac574ba9ac6b6038
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libcollections/smallintmap.rs

@@ -17,7 +17,6 @@ use core::prelude::*;
 
 use core::default::Default;
 use core::fmt;
-use core::iter;
 use core::iter::{Enumerate, FilterMap};
 use core::mem::replace;
 
@@ -195,18 +194,6 @@ impl<V> SmallIntMap<V> {
         self.find(key).expect("key not present")
     }
 
-    /// An iterator visiting all keys in ascending order by the keys.
-    /// Iterator element type is `uint`.
-    pub fn keys<'r>(&'r self) -> Keys<'r, V> {
-        self.iter().map(|(k, _v)| k)
-    }
-
-    /// An iterator visiting all values in ascending order by the keys.
-    /// Iterator element type is `&'r V`.
-    pub fn values<'r>(&'r self) -> Values<'r, V> {
-        self.iter().map(|(_k, v)| v)
-    }
-
     /// An iterator visiting all key-value pairs in ascending order by the keys.
     /// Iterator element type is `(uint, &'r V)`.
     ///
@@ -435,14 +422,6 @@ pub struct MutEntries<'a, T> {
 iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 
-/// Forward iterator over the keys of a map
-pub type Keys<'a, T> =
-    iter::Map<'static, (uint, &'a T), uint, Entries<'a, T>>;
-
-/// Forward iterator over the values of a map
-pub type Values<'a, T> =
-    iter::Map<'static, (uint, &'a T), &'a T, Entries<'a, T>>;
-
 #[cfg(test)]
 mod test_map {
     use std::prelude::*;
@@ -538,32 +517,6 @@ mod test_map {
         assert_eq!(m.pop(&1), None);
     }
 
-    #[test]
-    fn test_keys() {
-        let mut map = SmallIntMap::new();
-        map.insert(1, 'a');
-        map.insert(2, 'b');
-        map.insert(3, 'c');
-        let keys = map.keys().collect::<Vec<uint>>();
-        assert_eq!(keys.len(), 3);
-        assert!(keys.contains(&1));
-        assert!(keys.contains(&2));
-        assert!(keys.contains(&3));
-    }
-
-    #[test]
-    fn test_values() {
-        let mut map = SmallIntMap::new();
-        map.insert(1, 'a');
-        map.insert(2, 'b');
-        map.insert(3, 'c');
-        let values = map.values().map(|&v| v).collect::<Vec<char>>();
-        assert_eq!(values.len(), 3);
-        assert!(values.contains(&'a'));
-        assert!(values.contains(&'b'));
-        assert!(values.contains(&'c'));
-    }
-
     #[test]
     fn test_iterator() {
         let mut m = SmallIntMap::new();

branches/auto/src/libcollections/treemap.rs

@@ -141,16 +141,6 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Create an empty TreeMap
     pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
 
-    /// Get a lazy iterator over the keys in the map.
-    pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
-        self.iter().map(|(k, _v)| k)
-    }
-
-    /// Get a lazy iterator over the values in the map.
-    pub fn values<'a>(&'a self) -> Values<'a, K, V> {
-        self.iter().map(|(_k, v)| v)
-    }
-
     /// Get a lazy iterator over the key-value pairs in the map.
     /// Requires that it be frozen (immutable).
     pub fn iter<'a>(&'a self) -> Entries<'a, K, V> {
@@ -391,15 +381,6 @@ pub struct RevMutEntries<'a, K, V> {
 }
 
 
-/// TreeMap keys iterator
-pub type Keys<'a, K, V> =
-    iter::Map<'static, (&'a K, &'a V), &'a K, Entries<'a, K, V>>;
-
-/// TreeMap values iterator
-pub type Values<'a, K, V> =
-    iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
-
-
 // FIXME #5846 we want to be able to choose between &x and &mut x
 // (with many different `x`) below, so we need to optionally pass mut
 // as a tt, but the only thing we can do with a `tt` is pass them to
@@ -1489,28 +1470,6 @@ mod test_treemap {
         assert!(m_upper.iter().all(|(_, &x)| x == 0));
     }
 
-    #[test]
-    fn test_keys() {
-        let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<TreeMap<int, char>>();
-        let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
-        assert_eq!(keys.len(), 3);
-        assert!(keys.contains(&1));
-        assert!(keys.contains(&2));
-        assert!(keys.contains(&3));
-    }
-
-    #[test]
-    fn test_values() {
-        let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<TreeMap<int, char>>();
-        let values = map.values().map(|&v| v).collect::<Vec<char>>();
-        assert_eq!(values.len(), 3);
-        assert!(values.contains(&'a'));
-        assert!(values.contains(&'b'));
-        assert!(values.contains(&'c'));
-    }
-
     #[test]
     fn test_eq() {
         let mut a = TreeMap::new();

branches/auto/src/libcollections/trie.rs

@@ -18,7 +18,6 @@ use core::default::Default;
 use core::mem::zeroed;
 use core::mem;
 use core::uint;
-use core::iter;
 use std::hash::{Writer, Hash};
 
 use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
@@ -197,18 +196,6 @@ impl<T> TrieMap<T> {
         self.root.each_reverse(f)
     }
 
-    /// Get an iterator visiting all keys in ascending order by the keys.
-    /// Iterator element type is `uint`.
-    pub fn keys<'r>(&'r self) -> Keys<'r, T> {
-        self.iter().map(|(k, _v)| k)
-    }
-
-    /// Get an iterator visiting all values in ascending order by the keys.
-    /// Iterator element type is `&'r T`.
-    pub fn values<'r>(&'r self) -> Values<'r, T> {
-        self.iter().map(|(_k, v)| v)
-    }
-
     /// Get an iterator over the key-value pairs in the map, ordered by keys.
     ///
     /// # Example
@@ -796,14 +783,6 @@ pub struct MutEntries<'a, T> {
     remaining_max: uint
 }
 
-/// Forward iterator over the keys of a map
-pub type Keys<'a, T> =
-    iter::Map<'static, (uint, &'a T), uint, Entries<'a, T>>;
-
-/// Forward iterator over the values of a map
-pub type Values<'a, T> =
-    iter::Map<'static, (uint, &'a T), &'a T, Entries<'a, T>>;
-
 // FIXME #5846: see `addr!` above.
 macro_rules! item { ($i:item) => {$i}}
 
@@ -1091,28 +1070,6 @@ mod test_map {
         }
     }
 
-    #[test]
-    fn test_keys() {
-        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.move_iter().collect::<TrieMap<char>>();
-        let keys = map.keys().collect::<Vec<uint>>();
-        assert_eq!(keys.len(), 3);
-        assert!(keys.contains(&1));
-        assert!(keys.contains(&2));
-        assert!(keys.contains(&3));
-    }
-
-    #[test]
-    fn test_values() {
-        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.move_iter().collect::<TrieMap<char>>();
-        let values = map.values().map(|&v| v).collect::<Vec<char>>();
-        assert_eq!(values.len(), 3);
-        assert!(values.contains(&'a'));
-        assert!(values.contains(&'b'));
-        assert!(values.contains(&'c'));
-    }
-
     #[test]
     fn test_iteration() {
         let empty_map : TrieMap<uint> = TrieMap::new();

branches/auto/src/libcore/fmt/num.rs

@@ -119,7 +119,7 @@ pub struct Radix {
 
 impl Radix {
     fn new(base: u8) -> Radix {
-        assert!(2 <= base && base <= 36, "the base must be in the range of 0..36: {}", base);
+        assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base);
         Radix { base: base }
     }
 }

branches/auto/src/librustc/metadata/creader.rs

@@ -293,16 +293,13 @@ fn existing_match(e: &Env, name: &str,
         // library. Even though an upstream library may have loaded something of
         // the same name, we have to make sure it was loaded from the exact same
         // location as well.
-        //
-        // We're also sure to compare *paths*, not actual byte slices. The
-        // `source` stores paths which are normalized which may be different
-        // from the strings on the command line.
         let source = e.sess.cstore.get_used_crate_source(cnum).unwrap();
+        let dylib = source.dylib.as_ref().map(|p| p.as_vec());
+        let rlib = source.rlib.as_ref().map(|p| p.as_vec());
         match e.sess.opts.externs.find_equiv(&name) {
             Some(locs) => {
                 let found = locs.iter().any(|l| {
-                    let l = Some(Path::new(l.as_slice()));
-                    l == source.dylib || l == source.rlib
+                    Some(l.as_bytes()) == dylib || Some(l.as_bytes()) == rlib
                 });
                 if found {
                     ret = Some(cnum);

branches/auto/src/librustc/middle/borrowck/mod.rs

@@ -98,9 +98,9 @@ pub fn check_crate(tcx: &ty::ctxt,
     }
 
     fn make_stat(bccx: &BorrowckCtxt, stat: uint) -> String {
+        let stat_f = stat as f64;
         let total = bccx.stats.guaranteed_paths.get() as f64;
-        let perc = if total == 0.0 { 0.0 } else { stat as f64 * 100.0 / total };
-        format!("{} ({:.0f}%)", stat, perc)
+        format!("{} ({:.0f}%)", stat  , stat_f * 100.0 / total)
     }
 }