---

yaml
---
r: 63297
b: refs/heads/snap-stage3
c: 2b13606
h: refs/heads/master
i:
  63295: 7a59a88
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8431e609ea47ff7a396888233baf23159c620dca
+refs/heads/snap-stage3: 2b13606d9f8b8be381ed1934181f82e944856f22
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/core.rc

@@ -10,49 +10,49 @@
 
 /*!
 
-# The Rust core library
+# The Rust standard library
 
-The Rust core library provides runtime features required by the language,
+The Rust standard library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
 
-`core` includes modules corresponding to each of the integer types, each of
+`std` includes modules corresponding to each of the integer types, each of
 the floating point types, the `bool` type, tuples, characters, strings
 (`str`), vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`),
-and unsafe and borrowed pointers (`ptr`).  Additionally, `core` provides
+and unsafe and borrowed pointers (`ptr`).  Additionally, `std` provides
 pervasive types (`option` and `result`), task creation and communication
 primitives (`task`, `comm`), platform abstractions (`os` and `path`), basic
 I/O abstractions (`io`), common traits (`kinds`, `ops`, `cmp`, `num`,
 `to_str`), and complete bindings to the C standard library (`libc`).
 
-# Core injection and the Rust prelude
+# Standard library injection and the Rust prelude
 
-`core` is imported at the topmost level of every crate by default, as
+`std` is imported at the topmost level of every crate by default, as
 if the first line of each crate was
 
-    extern mod core;
+    extern mod std;
 
-This means that the contents of core can be accessed from any context
-with the `core::` path prefix, as in `use core::vec`, `use core::task::spawn`,
+This means that the contents of std can be accessed from any context
+with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`,
 etc.
 
-Additionally, `core` contains a `prelude` module that reexports many of the
-most common core modules, types and traits. The contents of the prelude are
+Additionally, `std` contains a `prelude` module that reexports many of the
+most common std modules, types and traits. The contents of the prelude are
 imported into every *module* by default.  Implicitly, all modules behave as if
 they contained the following prologue:
 
-    use core::prelude::*;
+    use std::prelude::*;
 
 */
 
 
 #[link(name = "std",
        vers = "0.7-pre",
        uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
-       url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
+       url = "https://github.com/mozilla/rust/tree/master/src/libstd")];
 
-#[comment = "The Rust core library"];
+#[comment = "The Rust standard library"];
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 

branches/snap-stage3/src/libsyntax/ext/deriving/rand.rs

@@ -79,19 +79,18 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
             let variant_count = cx.expr_uint(span, variants.len());
 
             // need to specify the uint-ness of the random number
-            let uint_ty = cx.ty_ident(span, cx.ident_of("uint"));
+            let u32_ty = cx.ty_ident(span, cx.ident_of("uint"));
             let r_ty = cx.ty_ident(span, cx.ident_of("R"));
-            let rand_name = cx.path_all(span, true, copy rand_ident, None, ~[ uint_ty, r_ty ]);
+            let rand_name = cx.path_all(span, false, copy rand_ident, None, ~[ u32_ty, r_ty ]);
             let rand_name = cx.expr_path(rand_name);
 
-            // ::std::rand::Rand::rand::<uint>(rng)
             let rv_call = cx.expr_call(span,
                                        rand_name,
                                        ~[ rng[0].duplicate(cx) ]);
 
             // rand() % variants.len()
             let rand_variant = cx.expr_binary(span, ast::rem,
-                                              rv_call, variant_count);
+                                                rv_call, variant_count);
 
             let mut arms = do variants.mapi |i, id_sum| {
                 let i_expr = cx.expr_uint(span, i);