---

yaml
---
r: 65446
b: refs/heads/master
c: ea633b4
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: aef1e10eba812b8144b0a4ac8d9b6e690c6e5ca7
+refs/heads/master: ea633b42aeadf807a10036a87bf2903123250152
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/rust.md

@@ -301,10 +301,10 @@ num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
 num_suffix : int_suffix | float_suffix ;
 
 int_suffix : 'u' int_suffix_size ?
-           | 'i' int_suffix_size ? ;
+           | 'i' int_suffix_size ;
 int_suffix_size : [ '8' | '1' '6' | '3' '2' | '6' '4' ] ;
 
-float_suffix : [ exponent | '.' dec_lit exponent ? ] ? float_suffix_ty ? ;
+float_suffix : [ exponent | '.' dec_lit exponent ? ] float_suffix_ty ? ;
 float_suffix_ty : 'f' [ '3' '2' | '6' '4' ] ;
 exponent : ['E' | 'e'] ['-' | '+' ] ? dec_lit ;
 dec_lit : [ dec_digit | '_' ] + ;
@@ -1840,7 +1840,6 @@ is bounds-checked at run-time. When the check fails, it will put the
 task in a _failing state_.
 
 ~~~~
-# use std::task;
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
@@ -2033,8 +2032,7 @@ as
 =
 ~~~~
 
-Operators at the same precedence level are evaluated left-to-right. [Unary operators](#unary-operator-expressions)
-have the same precedence level and it is stronger than any of the binary operators'.
+Operators at the same precedence level are evaluated left-to-right.
 
 ### Grouped expressions
 
@@ -2170,7 +2168,7 @@ fn ten_times(f: &fn(int)) {
     }
 }
 
-ten_times(|j| println(fmt!("hello, %d", j)));
+ten_times(|j| io::println(fmt!("hello, %d", j)));
 
 ~~~~
 
@@ -2191,7 +2189,7 @@ An example:
 let mut i = 0;
 
 while i < 10 {
-    println("hello\n");
+    io::println("hello\n");
     i = i + 1;
 }
 ~~~~
@@ -2337,7 +2335,6 @@ for v.each |e| {
 An example of a for loop over a series of integers:
 
 ~~~~
-# use std::uint;
 # fn bar(b:uint) { }
 for uint::range(0, 256) |i| {
     bar(i);
@@ -2801,7 +2798,6 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of `
 An example of an object type:
 
 ~~~~~~~~
-# use std::int;
 trait Printable {
   fn to_str(&self) -> ~str;
 }
@@ -2811,7 +2807,7 @@ impl Printable for int {
 }
 
 fn print(a: @Printable) {
-   println(a.to_str());
+   io::println(a.to_str());
 }
 
 fn main() {

trunk/doc/tutorial-ffi.md

@@ -149,9 +149,7 @@ A type with the same functionality as owned boxes can be implemented by
 wrapping `malloc` and `free`:
 
 ~~~~
-use std::cast;
 use std::libc::{c_void, size_t, malloc, free};
-use std::ptr;
 use std::unstable::intrinsics;
 use std::util;
 

trunk/doc/tutorial-tasks.md

@@ -120,7 +120,6 @@ should interleave the output in vaguely random order.
 ~~~
 # use std::io::print;
 # use std::task::spawn;
-# use std::int;
 
 for int::range(0, 20) |child_task_number| {
     do spawn {
@@ -237,7 +236,6 @@ Instead we can use a `SharedChan`, a type that allows a single
 ~~~
 # use std::task::spawn;
 # use std::comm::{stream, SharedChan};
-# use std::uint;
 
 let (port, chan) = stream();
 let chan = SharedChan::new(chan);
@@ -271,7 +269,6 @@ might look like the example below.
 ~~~
 # use std::task::spawn;
 # use std::comm::stream;
-# use std::vec;
 
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
@@ -313,8 +310,6 @@ the future needs to be mutable so that it can save the result for next time `get
 Here is another example showing how futures allow you to background computations. The workload will
 be distributed on the available cores.
 ~~~
-# use std::vec;
-# use std::uint;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for uint::range(start*100000, (start+1)*100000) |num| {
@@ -348,17 +343,14 @@ acts as a reference to the shared data and only this reference is shared and clo
 Here is a small example showing how to use ARCs. We wish to run concurrently several computations on
 a single large vector of floats. Each task needs the full vector to perform its duty.
 ~~~
-# use std::vec;
-# use std::uint;
-# use std::rand;
 use extra::arc::ARC;
 
 fn pnorm(nums: &~[float], p: uint) -> float {
     (vec::foldl(0.0, *nums, |a,b| a+(*b).pow(p as float) )).pow(1f / (p as float))
 }
 
 fn main() {
-    let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
+    let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
     println(fmt!("Inf-norm = %?",  numbers.max()));
 
     let numbers_arc = ARC(numbers);
@@ -381,16 +373,12 @@ at the power given as argument and takes the inverse power of this value). The A
 created by the line
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
-# let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
+# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 let numbers_arc=ARC(numbers);
 ~~~
 and a clone of it is sent to each task
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 # let numbers_arc = ARC(numbers);
 # let (port, chan)  = stream();
@@ -401,8 +389,6 @@ copying only the wrapper and not its contents.
 Each task recovers the underlying data by
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 # let numbers_arc=ARC(numbers);
 # let (port, chan)  = stream();
@@ -430,7 +416,6 @@ of all tasks are intertwined: if one fails, so do all the others.
 
 ~~~
 # use std::task::spawn;
-# use std::task;
 # fn do_some_work() { loop { task::yield() } }
 # do task::try {
 // Create a child task that fails
@@ -452,7 +437,6 @@ field (representing a successful result) or an `Err` result (representing
 termination with an error).
 
 ~~~
-# use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
 let result: Result<int, ()> = do task::try {
@@ -495,7 +479,6 @@ By default, task failure is _bidirectionally linked_, which means that if
 either task fails, it kills the other one.
 
 ~~~
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 do spawn {
@@ -518,7 +501,6 @@ before returning. Hence:
 ~~~
 # use std::comm::{stream, Chan, Port};
 # use std::task::{spawn, try};
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 let (receiver, sender): (Port<int>, Chan<int>) = stream();
@@ -546,7 +528,6 @@ Supervised task failure propagates across multiple generations even if
 an intermediate generation has already exited:
 
 ~~~
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # fn wait_for_a_while() { for 1000.times { task::yield() } }
 # do task::try::<int> {
@@ -565,7 +546,6 @@ Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
 ~~~
-# use std::task;
 # fn random() -> uint { 100 }
 # fn sleep_for(i: uint) { for i.times { task::yield() } }
 # do task::try::<()> {
@@ -594,7 +574,6 @@ Here is the function that implements the child task:
 
 ~~~~
 # use extra::comm::DuplexStream;
-# use std::uint;
 fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
@@ -617,7 +596,6 @@ Here is the code for the parent task:
 
 ~~~~
 # use std::task::spawn;
-# use std::uint;
 # use extra::comm::DuplexStream;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;

trunk/doc/tutorial.md

@@ -502,7 +502,6 @@ types.
 > items.
 
 ~~~~
-# use std::float;
 fn angle(vector: (float, float)) -> float {
     let pi = float::consts::pi;
     match vector {
@@ -557,7 +556,6 @@ while cake_amount > 0 {
 `loop` denotes an infinite loop, and is the preferred way of writing `while true`:
 
 ~~~~
-# use std::int;
 let mut x = 5;
 loop {
     x += x - 3;
@@ -701,7 +699,6 @@ get at their contents. All variant constructors can be used as
 patterns, as in this definition of `area`:
 
 ~~~~
-# use std::float;
 # struct Point {x: float, y: float}
 # enum Shape { Circle(Point, float), Rectangle(Point, Point) }
 fn area(sh: Shape) -> float {
@@ -1832,7 +1829,6 @@ vector consisting of the result of applying `function` to each element
 of `vector`:
 
 ~~~~
-# use std::vec;
 fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
     for vec::each(vector) |element| {
@@ -2030,7 +2026,6 @@ themselves contain type parameters. A trait for generalized sequence
 types might look like the following:
 
 ~~~~
-# use std::vec;
 trait Seq<T> {
     fn len(&self) -> uint;
     fn iter(&self, b: &fn(v: &T));

trunk/src/compiletest/compiletest.rc

@@ -16,13 +16,13 @@
 #[no_std];
 
 extern mod core(name = "std", vers = "0.7-pre");
-extern mod extra(name = "extra", vers = "0.7-pre");
+extern mod std(name = "extra", vers = "0.7-pre");
 
 use core::prelude::*;
 use core::*;
 
-use extra::getopts;
-use extra::test;
+use std::getopts;
+use std::test;
 
 use core::result::{Ok, Err};
 
@@ -42,13 +42,6 @@ pub mod runtest;
 pub mod common;
 pub mod errors;
 
-mod std {
-    pub use core::cmp;
-    pub use core::str;
-    pub use core::sys;
-    pub use core::unstable;
-}
-
 pub fn main() {
     let args = os::args();
     let config = parse_config(args);

trunk/src/compiletest/errors.rs

@@ -10,9 +10,6 @@
 
 use core::prelude::*;
 
-use core::io;
-use core::str;
-
 pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
 
 // Load any test directives embedded in the file

trunk/src/compiletest/header.rs

@@ -10,12 +10,8 @@
 
 use core::prelude::*;
 
-use common::config;
 use common;
-
-use core::io;
-use core::os;
-use core::str;
+use common::config;
 
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
@@ -99,7 +95,7 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     return false;
 
     fn xfail_target() -> ~str {
-        ~"xfail-" + os::SYSNAME
+        ~"xfail-" + str::to_owned(os::SYSNAME)
     }
 }
 
@@ -173,7 +169,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 
 fn parse_name_value_directive(line: &str,
                               directive: ~str) -> Option<~str> {
-    let keycolon = directive + ":";
+    let keycolon = directive + ~":";
     match str::find_str(line, keycolon) {
         Some(colon) => {
             let value = str::slice(line, colon + str::len(keycolon),

trunk/src/compiletest/procsrv.rs

@@ -10,26 +10,20 @@
 
 use core::prelude::*;
 
-use core::comm;
-use core::io;
-use core::libc::c_int;
-use core::os;
 use core::run;
-use core::str;
-use core::task;
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 
     let mut env = os::env();
 
     // Make sure we include the aux directory in the path
-    assert!(prog.ends_with(".exe"));
-    let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
+    assert!(prog.ends_with(~".exe"));
+    let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ~".libaux";
 
     env = do vec::map(env) |pair| {
         let (k,v) = *pair;
-        if k == ~"PATH" { (~"PATH", v + ";" + lib_path + ";" + aux_path) }
+        if k == ~"PATH" { (~"PATH", v + ~";" + lib_path + ~";" + aux_path) }
         else { (k,v) }
     };
     if str::ends_with(prog, "rustc.exe") {