Fix example in the docs

AUTHORS.txt

@@ -54,6 +54,7 @@ Gonçalo Cabrita <[email protected]>
 Graham Fawcett <[email protected]>
 Grahame Bowland <[email protected]>
 Haitao Li <[email protected]>
+Huon Wilson <[email protected]>
 Ian D. Bollinger <[email protected]>
 Ivano Coppola <[email protected]>
 Jacob Harris Cryer Kragh <[email protected]>

doc/rust.md

@@ -847,10 +847,25 @@ fn main() {
 
 Like items, `use` declarations are private to the containing module, by default.
 Also like items, a `use` declaration can be public, if qualified by the `pub` keyword.
+Such a `use` declaration serves to _re-export_ a name.
 A public `use` declaration can therefore be used to _redirect_ some public name to a different target definition,
 even a definition with a private canonical path, inside a different module.
 If a sequence of such redirections form a cycle or cannot be unambiguously resolved, they represent a compile-time error.
 
+An example of re-exporting:
+~~~~
+mod quux {
+    mod foo {
+        pub fn bar() { }
+        pub fn baz() { }
+    }
+
+    pub use foo::*;
+}
+~~~~
+
+In this example, the module `quux` re-exports all of the public names defined in `foo`.
+
 ### Functions
 
 A _function item_ defines a sequence of [statements](#statements) and an optional final [expression](#expressions), along with a name and a set of parameters.
@@ -2704,18 +2719,18 @@ The special type `self` has a meaning within methods inside an
 impl item. It refers to the type of the implicit `self` argument. For
 example, in:
 
-~~~~~~~~{.xfail-test}
+~~~~~~~~
 trait Printable {
-  fn to_str() -> ~str;
+  fn make_string() -> ~str;
 }
 
 impl ~str: Printable {
-  fn to_str() -> ~str { copy self }
+  fn make_string() -> ~str { copy self }
 }
 ~~~~~~~~
 
 `self` refers to the value of type `~str` that is the receiver for a
-call to the method `to_str`.
+call to the method `make_string`.
 
 ## Type kinds
 

doc/tutorial-tasks.md

@@ -150,7 +150,7 @@ come in a variety of forms, each one appropriate for a different use case. In
 what follows, we cover the most commonly used varieties.
 
 The simplest way to create a pipe is to use the `pipes::stream`
-function to create a `(Chan, Port)` pair. In Rust parlance, a *channel*
+function to create a `(Port, Chan)` pair. In Rust parlance, a *channel*
 is a sending endpoint of a pipe, and a *port* is the receiving
 endpoint. Consider the following example of calculating two results
 concurrently:
@@ -159,7 +159,7 @@ concurrently:
 use task::spawn;
 use pipes::{stream, Port, Chan};
 
-let (chan, port): (Chan<int>, Port<int>) = stream();
+let (port, chan): (Port<int>, Chan<int>) = stream();
 
 do spawn |move chan| {
     let result = some_expensive_computation();
@@ -179,7 +179,7 @@ a tuple into its component parts).
 
 ~~~~
 # use pipes::{stream, Chan, Port};
-let (chan, port): (Chan<int>, Port<int>) = stream();
+let (port, chan): (Port<int>, Chan<int>) = stream();
 ~~~~
 
 The child task will use the channel to send data to the parent task,
@@ -191,7 +191,7 @@ spawns the child task.
 # use task::spawn;
 # use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
-# let (chan, port) = stream();
+# let (port, chan) = stream();
 do spawn |move chan| {
     let result = some_expensive_computation();
     chan.send(result);
@@ -211,7 +211,7 @@ port:
 ~~~~
 # use pipes::{stream, Port, Chan};
 # fn some_other_expensive_computation() {}
-# let (chan, port) = stream::<int>();
+# let (port, chan) = stream::<int>();
 # chan.send(0);
 some_other_expensive_computation();
 let result = port.recv();
@@ -227,7 +227,7 @@ following program is ill-typed:
 # use task::{spawn};
 # use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
-let (chan, port) = stream();
+let (port, chan) = stream();
 
 do spawn |move chan| {
     chan.send(some_expensive_computation());
@@ -247,7 +247,7 @@ Instead we can use a `SharedChan`, a type that allows a single
 # use task::spawn;
 use pipes::{stream, SharedChan};
 
-let (chan, port) = stream();
+let (port, chan) = stream();
 let chan = SharedChan(move chan);
 
 for uint::range(0, 3) |init_val| {
@@ -282,7 +282,7 @@ might look like the example below.
 
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
-    let (chan, port) = stream();
+    let (port, chan) = stream();
     do spawn |move chan| {
         chan.send(some_expensive_computation(init_val));
     }
@@ -397,7 +397,7 @@ before returning. Hence:
 # use task::{spawn, try};
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
-let (sender, receiver): (Chan<int>, Port<int>) = stream();
+let (receiver, sender): (Port<int>, Chan<int>) = stream();
 do spawn |move receiver| {  // Bidirectionally linked
     // Wait for the supervised child task to exist.
     let message = receiver.recv();

src/libcargo/cargo.rc

@@ -42,26 +42,25 @@ extern mod std(vers = "0.5");
 extern mod rustc(vers = "0.5");
 extern mod syntax(vers = "0.5");
 
-use core::*;
-
 #[legacy_exports]
 mod pgp;
 
-use syntax::{ast, codemap, parse, visit, attr};
-use syntax::diagnostic::span_handler;
-use codemap::span;
-use rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest,
-                                     get_cargo_sysroot, libdir};
-use syntax::diagnostic;
+use rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest};
+use rustc::metadata::filesearch::{get_cargo_sysroot, libdir};
 
-use result::{Ok, Err};
-use io::WriterUtil;
-use send_map::linear::LinearMap;
+use core::*;
+
+use core::dvec::DVec;
+use core::io::WriterUtil;
+use core::result::{Ok, Err};
+use core::send_map::linear::LinearMap;
+use std::getopts::{optflag, optopt, opt_present};
+use std::map::HashMap;
 use std::{map, json, tempfile, term, sort, getopts};
-use map::HashMap;
-use to_str::to_str;
-use getopts::{optflag, optopt, opt_present};
-use dvec::DVec;
+use syntax::codemap::span;
+use syntax::diagnostic::span_handler;
+use syntax::diagnostic;
+use syntax::{ast, codemap, parse, visit, attr};
 
 struct Package {
     name: ~str,

src/libcore/at_vec.rs

@@ -61,7 +61,7 @@ pub pure fn build_sized<A>(size: uint,
                            builder: &fn(push: pure fn(v: A))) -> @[A] {
     let mut vec: @[const A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
-    builder(|+x| unsafe { raw::push(&mut vec, move x) });
+    builder(|+x| unsafe { raw::push(&mut vec, x) });
     return unsafe { transmute(vec) };
 }
 
@@ -178,10 +178,10 @@ pub mod raw {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
-            push_fast(v, move initval);
+            push_fast(v, initval);
         }
         else {
-            push_slow(v, move initval);
+            push_slow(v, initval);
         }
     }
 

src/libcore/cast.rs

@@ -130,10 +130,11 @@ pub mod tests {
 
     #[test]
     pub fn test_transmute() {
+        use managed::raw::BoxRepr;
         unsafe {
-            let x = @1;
-            let x: *int = transmute(move x);
-            assert *x == 1;
+            let x = @100u8;
+            let x: *BoxRepr = transmute(move x);
+            assert (*x).data == 100;
             let _x: @int = transmute(move x);
         }
     }

src/libcore/char.rs

@@ -149,7 +149,7 @@ pub pure fn escape_unicode(c: char) -> ~str {
             { str::push_str(&mut out, ~"0"); }
         str::push_str(&mut out, s);
     }
-    move out
+    out
 }
 
 /**

src/libcore/cleanup.rs

@@ -152,7 +152,7 @@ pub unsafe fn annihilate() {
         assert (*box).header.prev == null();
 
         debug!("freeing box: %x", box as uint);
-        rt_free(transmute(move box));
+        rt_free(transmute(box));
     }
 }
 

src/libcore/core.rc

@@ -247,7 +247,7 @@ mod core {
 #[cfg(test)]
 mod std {
     extern mod std(vers = "0.5");
-    pub use std::test;
+    pub use std::std::test;
 }
 
 

src/libcore/int-template.rs

@@ -12,7 +12,12 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+#[cfg(stage0)]
 use T = inst::T;
+#[cfg(stage1)]
+#[cfg(stage2)]
+use T = self::inst::T;
+
 use cmp::{Eq, Ord};
 use from_str::FromStr;
 use num::from_int;

src/libcore/int-template/int.rs

@@ -10,7 +10,11 @@
 
 //! Operations and constants for `int`
 
+#[cfg(stage0)]
 pub use inst::pow;
+#[cfg(stage1)]
+#[cfg(stage2)]
+pub use self::inst::pow;
 
 mod inst {
     pub type T = int;
@@ -54,4 +58,4 @@ mod inst {
         assert (min_value <= 0);
         assert (min_value + max_value + 1 == 0);
     }
-}
+}

src/libcore/iter-trait.rs

@@ -16,7 +16,12 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
+
+#[cfg(stage0)]
 use inst::{IMPL_T, EACH, SIZE_HINT};
+#[cfg(stage1)]
+#[cfg(stage2)]
+use self::inst::{IMPL_T, EACH, SIZE_HINT};
 
 impl<A> IMPL_T<A>: iter::BaseIter<A> {
     pure fn each(blk: fn(v: &A) -> bool) { EACH(&self, blk) }