---

yaml
---
r: 152135
b: refs/heads/try2
c: 1b3a030
h: refs/heads/master
i:
  152133: 471daf9
  152131: e641c93
  152127: 320b8a7
v: v3

Author: lucy

[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: 25951b22420c5ecb1428a225a4dbb9e7529cf181
+refs/heads/try2: 1b3a03009215b518572b03dd4bf02dbcba129527
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.gitignore

@@ -60,6 +60,7 @@ config.mk
 /rt/
 /rustllvm/
 /test/
+/build
 /inst/
 /mingw-build/
 src/.DS_Store

branches/try2/mk/crates.mk

@@ -60,9 +60,9 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core rand libc alloc native:rustrt native:backtrace
+DEPS_std := core libc alloc native:rustrt native:backtrace
 DEPS_graphviz := std
-DEPS_green := std native:context_switch
+DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize collections log fmt_macros debug
@@ -77,16 +77,16 @@ DEPS_glob := std
 DEPS_serialize := std collections log
 DEPS_term := std collections log
 DEPS_semver := std
-DEPS_uuid := std serialize
+DEPS_uuid := std serialize rand
 DEPS_sync := std alloc
 DEPS_getopts := std
-DEPS_collections := std debug
+DEPS_collections := std rand debug
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
-DEPS_num := std
+DEPS_num := std rand
 DEPS_test := std collections getopts serialize term time regex
 DEPS_time := std serialize sync
-DEPS_rand := core
+DEPS_rand := std
 DEPS_url := std collections
 DEPS_workcache := std serialize collections log
 DEPS_log := std sync
@@ -104,7 +104,6 @@ TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 ONLY_RLIB_core := 1
 ONLY_RLIB_rlibc := 1
 ONLY_RLIB_alloc := 1
-ONLY_RLIB_rand := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/try2/src/doc/guide-tasks.md

@@ -329,10 +329,10 @@ Here is a small example showing how to use Arcs. We wish to run concurrently sev
 a single large vector of floats. Each task needs the full vector to perform its duty.
 
 ~~~
+extern crate rand;
 extern crate sync;
 
 use sync::Arc;
-use std::rand;
 
 fn pnorm(nums: &[f64], p: uint) -> f64 {
     nums.iter().fold(0.0, |a, b| a + b.powf(p as f64)).powf(1.0 / (p as f64))
@@ -358,7 +358,7 @@ created by the line
 
 ~~~
 # extern crate sync;
-# use std::rand;
+# extern crate rand;
 # use sync::Arc;
 # fn main() {
 # let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
@@ -372,7 +372,7 @@ reference to the underlying vector as if it were local.
 
 ~~~
 # extern crate sync;
-# use std::rand;
+# extern crate rand;
 # use sync::Arc;
 # fn pnorm(nums: &[f64], p: uint) -> f64 { 4.0 }
 # fn main() {

branches/try2/src/doc/rust.md

@@ -1036,7 +1036,6 @@ Unsafe operations are those that potentially violate the memory-safety guarantee
 The following language level features cannot be used in the safe subset of Rust:
 
   - Dereferencing a [raw pointer](#pointer-types).
-  - Reading or writing a [mutable static variable](#mutable-statics).
   - Calling an unsafe function (including an intrinsic or foreign function).
 
 ##### Unsafe functions

branches/try2/src/doc/tutorial.md

@@ -1112,7 +1112,7 @@ let ys = xs;
 
 xs = Nil;
 
-// `xs` can be used again
+// `xs` can't be used again
 ~~~
 
 A destructor call will only occur for a variable that has not been moved from,

branches/try2/src/liballoc/arc.rs

@@ -160,8 +160,7 @@ impl<T: Send + Share + Clone> Arc<T> {
         // reference count is guaranteed to be 1 at this point, and we required
         // the Arc itself to be `mut`, so we're returning the only possible
         // reference to the inner data.
-        let inner = unsafe { &mut *self._ptr };
-        &mut inner.data
+        unsafe { mem::transmute::<&_, &mut _>(self.deref()) }
     }
 }
 

branches/try2/src/libcollections/bitv.rs

@@ -980,8 +980,8 @@ mod tests {
     use bitv;
 
     use std::uint;
-    use std::rand;
-    use std::rand::Rng;
+    use rand;
+    use rand::Rng;
 
     static BENCH_BITS : uint = 1 << 14;
 

branches/try2/src/libcollections/deque.rs

@@ -44,8 +44,8 @@ pub mod bench {
     extern crate test;
     use self::test::Bencher;
     use std::container::MutableMap;
-    use std::rand;
-    use std::rand::Rng;
+    use rand;
+    use rand::Rng;
 
     pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                   map: &mut M,

branches/try2/src/libcollections/dlist.rs

@@ -610,7 +610,7 @@ mod tests {
     extern crate test;
     use self::test::Bencher;
     use deque::Deque;
-    use std::rand;
+    use rand;
     use super::{DList, Node, ListInsertion};
 
     pub fn check_links<T>(list: &DList<T>) {

branches/try2/src/libcollections/hashmap.rs

@@ -24,8 +24,8 @@ use std::iter::{range, range_inclusive};
 use std::mem::replace;
 use std::num;
 use std::option::{Option, Some, None};
-use std::rand;
-use std::rand::Rng;
+use rand;
+use rand::Rng;
 use std::result::{Ok, Err};
 use std::slice::ImmutableVector;
 

branches/try2/src/libcollections/lib.rs

@@ -24,6 +24,7 @@
 
 #![deny(deprecated_owned_vector)]
 
+extern crate rand;
 extern crate debug;
 
 #[cfg(test)] extern crate test;

branches/try2/src/libcollections/treemap.rs

@@ -1000,8 +1000,8 @@ impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
 mod test_treemap {
     use super::{TreeMap, TreeNode};
 
-    use std::rand::Rng;
-    use std::rand;
+    use rand::Rng;
+    use rand;
 
     #[test]
     fn find_empty() {

branches/try2/src/libcollections/trie.rs

@@ -915,7 +915,7 @@ mod test_map {
 mod bench_map {
     extern crate test;
     use super::TrieMap;
-    use std::rand::{weak_rng, Rng};
+    use rand::{weak_rng, Rng};
     use self::test::Bencher;
 
     #[bench]

branches/try2/src/libcore/any.rs

@@ -119,7 +119,7 @@ mod tests {
     use prelude::*;
     use super::*;
     use realstd::owned::{Box, AnyOwnExt};
-    use realstd::str::Str;
+    use realstd::str::{Str, StrAllocating};
 
     #[deriving(Eq, Show)]
     struct Test;

branches/try2/src/libcore/char.rs

@@ -607,7 +607,7 @@ mod test {
     use slice::ImmutableVector;
     use option::{Some, None};
     use realstd::string::String;
-    use realstd::str::Str;
+    use realstd::str::{Str, StrAllocating};
 
     #[test]
     fn test_is_lowercase() {

branches/try2/src/libcore/cmp.rs

@@ -37,9 +37,6 @@
 //! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
 //! ```
 
-pub use PartialEq = cmp::Eq;
-pub use PartialOrd = cmp::Ord;
-
 /// Trait for values that can be compared for equality and inequality.
 ///
 /// This trait allows partial equality, where types can be unordered instead of

branches/try2/src/libcore/fmt/mod.rs

@@ -596,6 +596,7 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result,
 #[cfg(test)]
 pub fn format(args: &Arguments) -> ::realstd::string::String {
     use str;
+    use realstd::str::StrAllocating;
     use realstd::io::MemWriter;
 
     fn mywrite<T: ::realstd::io::Writer>(t: &mut T, b: &[u8]) {

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

@@ -194,7 +194,7 @@ mod tests {
     use fmt::radix;
     use super::{Binary, Octal, Decimal, LowerHex, UpperHex};
     use super::{GenericRadix, Radix};
-    use realstd::str::Str;
+    use realstd::str::{Str, StrAllocating};
 
     #[test]
     fn test_radix_base() {
@@ -399,71 +399,71 @@ mod bench {
     mod uint {
         use super::test::Bencher;
         use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
+        use rand::{XorShiftRng, Rng};
 
         #[bench]
         fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
         }
 
         #[bench]
         fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
         }
 
         #[bench]
         fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
         }
 
         #[bench]
         fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
         }
 
         #[bench]
         fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
         }
     }
 
     mod int {
         use super::test::Bencher;
         use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
+        use rand::{XorShiftRng, Rng};
 
         #[bench]
         fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:t}", rng.gen::<int>()); })
         }
 
         #[bench]
         fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:o}", rng.gen::<int>()); })
         }
 
         #[bench]
         fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:d}", rng.gen::<int>()); })
         }
 
         #[bench]
         fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{:x}", rng.gen::<int>()); })
         }
 
         #[bench]
         fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
         }
     }

branches/try2/src/libcore/lib.rs

@@ -59,6 +59,7 @@
 #[cfg(test)] extern crate realcore = "core";
 #[cfg(test)] extern crate libc;
 #[cfg(test)] extern crate native;
+#[cfg(test)] extern crate rand;
 #[cfg(test)] extern crate realstd = "std";
 
 #[cfg(test)] pub use cmp = realcore::cmp;

branches/try2/src/libcore/result.rs

@@ -637,10 +637,11 @@ pub fn fold_<T,E,Iter:Iterator<Result<T,E>>>(iterator: Iter) -> Result<(),E> {
 #[cfg(test)]
 mod tests {
     use realstd::vec::Vec;
+    use realstd::string::String;
 
     use result::{collect, fold, fold_};
     use prelude::*;
-    use realstd::str::Str;
+    use realstd::str::{Str, StrAllocating};
     use iter::range;
 
     pub fn op1() -> Result<int, &'static str> { Ok(666) }

branches/try2/src/libcore/tuple.rs

@@ -294,7 +294,7 @@ mod tests {
     use super::*;
     use clone::Clone;
     use cmp::*;
-    use realstd::str::Str;
+    use realstd::str::{Str, StrAllocating};
 
     #[test]
     fn test_clone() {

branches/try2/src/libflate/lib.rs

@@ -108,9 +108,10 @@ pub fn inflate_bytes_zlib(bytes: &[u8]) -> Option<CVec<u8>> {
 
 #[cfg(test)]
 mod tests {
+    extern crate rand;
+
     use super::{inflate_bytes, deflate_bytes};
-    use std::rand;
-    use std::rand::Rng;
+    use self::rand::Rng;
 
     #[test]
     #[allow(deprecated_owned_vector)]
@@ -119,8 +120,7 @@ mod tests {
         let mut words = vec!();
         for _ in range(0, 20) {
             let range = r.gen_range(1u, 10);
-            let v = r.gen_iter::<u8>().take(range).collect::<Vec<u8>>();
-            words.push(v);
+            words.push(r.gen_vec::<u8>(range));
         }
         for _ in range(0, 20) {
             let mut input = vec![];

branches/try2/src/libgreen/lib.rs

@@ -212,6 +212,7 @@
 
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 #[cfg(test)] extern crate rustuv;
+extern crate rand;
 extern crate libc;
 extern crate alloc;