Copy first batch of material from libstd to libcore.

src/test/run-pass/acyclic-unwind.rs

@@ -2,8 +2,8 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
-import std::task;
+import comm;
+import task;
 
 fn f(c: comm::_chan<int>) {
     type t = {_0: int, _1: int, _2: int};

src/test/run-pass/alias-uninit-value.rs

@@ -2,8 +2,8 @@
 
 // Regression test for issue #374
 use std;
-import std::option;
-import std::option::none;
+import option;
+import option::none;
 
 tag sty { ty_nil; }
 

src/test/run-pass/alt-bot.rs

@@ -1,5 +1,5 @@
 use std;
-import std::option::*;
+import option::*;
 
 fn main() {
     let i: int =

src/test/run-pass/alt-join.rs

@@ -1,9 +1,9 @@
 
 use std;
-import std::option;
-import std::option::t;
-import std::option::none;
-import std::option::some;
+import option;
+import option::t;
+import option::none;
+import option::some;
 
 fn foo<T>(y: option::t<T>) {
     let x: int;

src/test/run-pass/basic-1.rs

@@ -1,11 +1,11 @@
 // -*- rust -*-
 
 use std;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::send;
-import std::comm::recv;
-import std::task;
+import comm::chan;
+import comm::port;
+import comm::send;
+import comm::recv;
+import task;
 
 fn a(c: chan<int>) { send(c, 10); }
 

src/test/run-pass/basic-2.rs

@@ -1,11 +1,11 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
-import std::comm::send;
-import std::comm::chan;
-import std::comm::recv;
-import std::task;
+import comm;
+import comm::send;
+import comm::chan;
+import comm::recv;
+import task;
 
 fn a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
 

src/test/run-pass/basic.rs

@@ -1,11 +1,11 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
-import std::comm::send;
-import std::comm::chan;
-import std::comm::recv;
-import std::task;
+import comm;
+import comm::send;
+import comm::chan;
+import comm::recv;
+import task;
 
 fn a(c: chan<int>) {
     if true {

src/test/run-pass/bind-native-fn.rs

@@ -2,8 +2,8 @@
 // xfail-test bots are crashing on this on x86_64
 
 use std;
-import std::str;
-import std::ctypes::*;
+import str;
+import ctypes::*;
 
 #[link_name = ""]
 native mod libc {
@@ -14,7 +14,7 @@ fn main() {
     let s = "hello world\n";
     let b = str::bytes(s);
     let l = str::byte_len(s);
-    let b8 = unsafe { std::vec::unsafe::to_ptr(b) };
+    let b8 = unsafe { vec::unsafe::to_ptr(b) };
     libc::write(0i32, b8, l);
     let a = bind libc::write(0i32, _, _);
     a(b8, l);

src/test/run-pass/binops.rs

@@ -1,9 +1,9 @@
 // Binop corner cases
 
 use std;
-import std::unsafe::reinterpret_cast;
-import std::task;
-import std::comm;
+import unsafe::reinterpret_cast;
+import task;
+import comm;
 
 fn test_nil() {
     assert (() == ());

src/test/run-pass/block-vec-map2.rs

@@ -1,9 +1,9 @@
 use std;
-import std::vec;
+import vec;
 
 fn main() {
     let v =
-        std::vec::map2({|i, b| if b { -i } else { i } }, [1, 2, 3, 4, 5],
+        vec::map2({|i, b| if b { -i } else { i } }, [1, 2, 3, 4, 5],
                        [true, false, false, true, true]);
     log_err v;
     assert (v == [-1, 2, 3, -4, -5]);

src/test/run-pass/c-stack-returning-int64.rs

@@ -1,5 +1,5 @@
 use std;
-import std::str;
+import str;
 
 #[abi = "cdecl"]
 #[link_name = ""]

src/test/run-pass/chan-leak.rs

@@ -1,12 +1,12 @@
 // Issue #763
 
 use std;
-import std::task;
-import std::comm::chan;
-import std::comm::send;
-import std::comm;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import comm::chan;
+import comm::send;
+import comm;
+import comm::port;
+import comm::recv;
 
 tag request { quit; close(chan<bool>); }
 

src/test/run-pass/check-pattern-bound.rs

@@ -1,5 +1,5 @@
 use std;
-import std::option::*;
+import option::*;
 
 pure fn p(x: int) -> bool { true }
 

src/test/run-pass/child-outlives-parent.rs

@@ -1,7 +1,7 @@
 // Reported as issue #126, child leaks the string.
 
 use std;
-import std::task;
+import task;
 
 fn child2(&&s: str) { }
 

src/test/run-pass/claim-nonterm.rs

@@ -1,6 +1,6 @@
 // tests that the pred in a claim isn't actually eval'd
 use std;
-import std::uint::*;
+import uint::*;
 
 pure fn fails(a: uint) -> bool { fail; }
 

src/test/run-pass/clone-with-exterior.rs

@@ -1,7 +1,7 @@
 //xfail-test
 
 use std;
-import std::task;
+import task;
 
 fn f(x : @{a:int, b:int}) {
     assert (x.a == 10);

src/test/run-pass/comm.rs

@@ -1,11 +1,11 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::recv;
-import std::task;
+import comm;
+import comm::chan;
+import comm::send;
+import comm::recv;
+import task;
 
 fn main() {
     let p = comm::port();

src/test/run-pass/constraint-prop-expr-move.rs

@@ -1,6 +1,6 @@
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 1u;

src/test/run-pass/constraint-prop-move.rs

@@ -1,6 +1,6 @@
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 1u;

src/test/run-pass/constraint-prop-swap.rs

@@ -1,6 +1,6 @@
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 4u;

src/test/run-pass/constraint-prop.rs

@@ -1,6 +1,6 @@
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 1u;

src/test/run-pass/decl-with-recv.rs

@@ -1,10 +1,10 @@
 // -*- rust -*-
 
 use std;
-import std::comm::port;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::recv;
+import comm::port;
+import comm::chan;
+import comm::send;
+import comm::recv;
 
 fn main() {
     let po = port();

src/test/run-pass/float-nan.rs

@@ -1,5 +1,5 @@
 use std;
-import std::float;
+import float;
 
 fn main() {
   let nan = float::NaN;

src/test/run-pass/fn-bare-size.rs

@@ -4,6 +4,6 @@ use std;
 
 fn main() {
     // Bare functions should just be a pointer
-    assert std::sys::rustrt::size_of::<fn()>() ==
-        std::sys::rustrt::size_of::<int>();
+    assert sys::rustrt::size_of::<fn()>() ==
+        sys::rustrt::size_of::<int>();
 }

src/test/run-pass/fn-constraint.rs

@@ -1,6 +1,6 @@
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 1u;

src/test/run-pass/hashmap-memory.rs

@@ -6,18 +6,18 @@
 
 use std;
 
-import option = std::option::t;
-import std::option::some;
-import std::option::none;
-import std::str;
-import std::vec;
+import option = option::t;
+import option::some;
+import option::none;
+import str;
+import vec;
 import std::map;
-import std::task;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::send;
-import std::comm::recv;
-import std::comm;
+import task;
+import comm::chan;
+import comm::port;
+import comm::send;
+import comm::recv;
+import comm;
 
 fn map(filename: str, emit: map_reduce::putter) { emit(filename, "1"); }
 

src/test/run-pass/import-glob-crate.rs

@@ -1,6 +1,6 @@
 
 use std;
-import std::vec::*;
+import vec::*;
 
 fn main() {
     let v = init_elt(0, 0u);

src/test/run-pass/import-in-block.rs

@@ -1,7 +1,7 @@
 use std;
 
 fn main() {
-    import std::vec;
+    import vec;
     import vec::to_mut;
     log vec::len(to_mut([1, 2]));
     {

src/test/run-pass/infinite-loops.rs

@@ -5,7 +5,7 @@
 // xfail-test
 
 use std;
-import std::task::join;
+import task::join;
 
 fn loop(n: int) {
     let t1: task;

src/test/run-pass/invoke-external-native.rs

@@ -1,5 +1,5 @@
 use std;
-import std::sys;
+import sys;
 
 // The purpose of this test is to check that we can
 // successfully (and safely) invoke external, cdecl

src/test/run-pass/issue-1112.rs

@@ -2,7 +2,7 @@
 // Alignment of interior pointers to dynamic-size types
 
 use std;
-import std::ptr::addr_of;
+import ptr::addr_of;
 
 type x<T> = {
     a: T,

src/test/run-pass/issue-506.rs

@@ -8,7 +8,7 @@
 */
 
 use std;
-import std::task;
+import task;
 
 #[abi = "cdecl"]
 native mod rustrt {

src/test/run-pass/issue-507.rs

@@ -7,13 +7,13 @@
 
 use std;
 
-import std::task;
-import std::task::join;
-import std::comm;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import task::join;
+import comm;
+import comm::chan;
+import comm::send;
+import comm::port;
+import comm::recv;
 
 fn grandchild(c: chan<int>) { send(c, 42); }
 

src/test/run-pass/issue-511.rs

@@ -1,5 +1,5 @@
 use std;
-import std::option;
+import option;
 
 fn f<T>(&o: option::t<T>) {
     assert o == option::none;

src/test/run-pass/issue-687.rs

@@ -1,11 +1,11 @@
 use std;
-import std::vec;
-import std::task;
-import std::comm;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::recv;
-import std::comm::send;
+import vec;
+import task;
+import comm;
+import comm::chan;
+import comm::port;
+import comm::recv;
+import comm::send;
 
 tag msg { closed; received([u8]); }
 

src/test/run-pass/issue-783.rs

@@ -1,6 +1,6 @@
 use std;
-import std::comm::*;
-import std::task::*;
+import comm::*;
+import task::*;
 
 fn a(&&_args: ()) {
     fn doit() {

src/test/run-pass/ivec-tag.rs

@@ -1,11 +1,11 @@
 use std;
 
-import std::task;
-import std::comm;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::send;
-import std::comm::recv;
+import task;
+import comm;
+import comm::chan;
+import comm::port;
+import comm::send;
+import comm::recv;
 
 fn producer(c: chan<[u8]>) {
     send(c,

src/test/run-pass/join.rs

@@ -2,7 +2,7 @@
 
 use std;
 
-import std::task::*;
+import task::*;
 
 fn main() {
     let other = spawn_joinable((), child);

src/test/run-pass/lazychan.rs

@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 use std;
-import std::task;
-import std::comm::*;
+import task;
+import comm::*;
 
 fn main() {
     let p = port();

src/test/run-pass/linked-failure.rs

@@ -1,9 +1,9 @@
 // -*- rust -*-
 // xfail-win32
 use std;
-import std::task;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import comm::port;
+import comm::recv;
 
 fn child(&&_i: ()) { assert (1 == 2); }
 

src/test/run-pass/lots-a-fail.rs

@@ -1,8 +1,8 @@
 // xfail-win32 leaks
 use std;
-import std::task;
-import std::comm;
-import std::uint;
+import task;
+import comm;
+import uint;
 
 fn die(&&_i: ()) {
     fail;

src/test/run-pass/many.rs

@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 fn sub(&&args: (comm::chan<int>, int)) {
     let (parent, id) = args;

src/test/run-pass/mlist-cycle.rs

@@ -10,6 +10,6 @@ fn main() {
     let first: @cell = @{mutable c: @nil()};
     let second: @cell = @{mutable c: @link(first)};
     first._0 = @link(second);
-    std::sys.rustrt.gc();
+    sys.rustrt.gc();
     let third: @cell = @{mutable c: @nil()};
 }

src/test/run-pass/mod-view-items.rs

@@ -6,7 +6,7 @@
 
 mod m {
     use std;
-    import std::vec;
+    import vec;
     fn f() -> [int] { vec::init_elt(0, 1u) }
 }
 

src/test/run-pass/morestack5.rs

@@ -4,7 +4,7 @@
 // This test will call __morestack with various minimum stack sizes
 
 use std;
-import std::task;
+import task;
 
 native mod rustrt {
     fn set_min_stack(size: uint);

src/test/run-pass/morestack6.rs

@@ -5,7 +5,7 @@
 // external symbols as close to the red zone as possible.
 
 use std;
-import std::task;
+import task;
 import std::rand;
 
 native mod rustrt {

src/test/run-pass/move-3-unique.rs

@@ -1,5 +1,5 @@
 use std;
-import std::uint;
+import uint;
 
 fn test(x: bool, foo: ~{x: int, y: int, z: int}) -> int {
     let bar = foo;

src/test/run-pass/move-3.rs

@@ -1,5 +1,5 @@
 use std;
-import std::uint;
+import uint;
 
 fn test(x: bool, foo: @{x: int, y: int, z: int}) -> int {
     let bar = foo;

src/test/run-pass/move-4-unique.rs

@@ -1,5 +1,5 @@
 use std;
-import std::uint;
+import uint;
 
 fn test(foo: ~{a: int, b: int, c: int}) -> ~{a: int, b: int, c: int} {
     let foo = foo;

src/test/run-pass/move-4.rs

@@ -1,6 +1,6 @@
 
 use std;
-import std::uint;
+import uint;
 
 fn test(foo: @{a: int, b: int, c: int}) -> @{a: int, b: int, c: int} {
     let foo = foo;

src/test/run-pass/mutable-alias-vec.rs

@@ -10,7 +10,7 @@ fn main() {
     grow(v);
     grow(v);
     grow(v);
-    let len = std::vec::len::<int>(v);
+    let len = vec::len::<int>(v);
     log len;
     assert (len == 3 as uint);
 }

src/test/run-pass/native-fn-linkname.rs

@@ -1,7 +1,7 @@
 use std;
 
-import std::vec;
-import std::str;
+import vec;
+import str;
 
 #[link_name = ""]
 #[abi = "cdecl"]

src/test/run-pass/nested-alts.rs

@@ -1,6 +1,6 @@
 
 use std;
-import std::option::*;
+import option::*;
 
 fn baz() -> ! { fail; }
 

src/test/run-pass/nested-pattern.rs

@@ -2,9 +2,9 @@
 
 // a bug was causing this to complain about leaked memory on exit
 use std;
-import std::option;
-import std::option::some;
-import std::option::none;
+import option;
+import option::some;
+import option::none;
 
 tag t { foo(int, uint); bar(int, option::t<int>); }
 

src/test/run-pass/obj-docs.rs

@@ -1,9 +1,9 @@
 // Sanity-check the code examples that appear in the object system
 // documentation.
 use std;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::port;
+import comm::chan;
+import comm::send;
+import comm::port;
 
 fn main() {
 

src/test/run-pass/pattern-bound-var-in-for-each.rs

@@ -2,8 +2,8 @@
 // pattern-bound var is an upvar (when translating
 // the for-each body)
 use std;
-import std::option::*;
-import std::uint;
+import option::*;
+import uint;
 
 fn foo(src: uint) {
 

src/test/run-pass/rt-circular-buffer.rs

@@ -3,13 +3,13 @@
 // Regression tests for circular_buffer when using a unit
 // that has a size that is not a power of two
 use std;
-import std::option;
-import std::uint;
-import std::comm;
-import std::comm::port;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::recv;
+import option;
+import uint;
+import comm;
+import comm::port;
+import comm::chan;
+import comm::send;
+import comm::recv;
 
 // A 12-byte unit to send over the channel
 type record = {val1: u32, val2: u32, val3: u32};

src/test/run-pass/send-iloop.rs

@@ -1,8 +1,8 @@
 // xfail-win32
 use std;
-import std::task;
-import std::comm;
-import std::uint;
+import task;
+import comm;
+import uint;
 
 fn die(&&_i: ()) {
     fail;

src/test/run-pass/send-type-inference.rs

@@ -1,7 +1,7 @@
 use std;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::port;
+import comm::chan;
+import comm::send;
+import comm::port;
 
 // tests that ctrl's type gets inferred properly
 type command<send K, send V> = {key: K, val: V};

src/test/run-pass/shape_intrinsic_tag_then_rec.rs

@@ -5,7 +5,7 @@
 use std;
 import std::list;
 import std::list::list;
-import std::option;
+import option;
 
 tag opt_span {
 

src/test/run-pass/spawn-fn.rs

@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 use std;
-import std::task::yield;
-import std::task;
+import task::yield;
+import task;
 
 fn x(&&args: (str, int)) {
     let (s, n) = args;

src/test/run-pass/spawn-module-qualified.rs

@@ -1,6 +1,6 @@
 use std;
-import std::task::join;
-import std::task::spawn_joinable;
+import task::join;
+import task::spawn_joinable;
 
 fn main() { let x = spawn_joinable(10, m::child); join(x); }
 

src/test/run-pass/spawn-types.rs

@@ -6,9 +6,9 @@
 
 use std;
 
-import std::str;
-import std::comm;
-import std::task;
+import str;
+import comm;
+import task;
 
 type ctx = comm::chan<int>;
 

src/test/run-pass/spawn.rs

@@ -2,7 +2,7 @@
 
 use std;
 
-import std::task;
+import task;
 
 fn main() { let t = task::spawn_joinable(10, child); task::join(t); }
 

src/test/run-pass/spawn2.rs

@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std::task::spawn;
+import task::spawn;
 
 fn main() { spawn((10, 20, 30, 40, 50, 60, 70, 80, 90), child); }
 

src/test/run-pass/str-append.rs

@@ -2,7 +2,7 @@
 
 // -*- rust -*-
 use std;
-import std::str;
+import str;
 
 fn test1() {
     let s: str = "hello";

src/test/run-pass/str-multiline.rs

@@ -2,7 +2,7 @@
 
 // -*- rust -*-
 use std;
-import std::str;
+import str;
 
 fn main() {
     let a: str = "this \

src/test/run-pass/string-self-append.rs

@@ -1,5 +1,5 @@
 use std;
-import std::str;
+import str;
 
 fn main() {
     // Make sure we properly handle repeated self-appends.

src/test/run-pass/syntax-extension-fmt.rs

@@ -1,5 +1,5 @@
 use std;
-import std::str;
+import str;
 
 fn test(actual: str, expected: str) {
     log actual;

src/test/run-pass/task-comm-0.rs

@@ -1,9 +1,9 @@
 use std;
 
-import std::comm;
-import std::comm::chan;
-import std::comm::send;
-import std::task;
+import comm;
+import comm::chan;
+import comm::send;
+import task;
 
 fn main() { test05(); }
 

src/test/run-pass/task-comm-1.rs

@@ -1,7 +1,7 @@
 use std;
 
-import std::task::spawn_joinable;
-import std::task::join;
+import task::spawn_joinable;
+import task::join;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-10.rs

@@ -1,6 +1,6 @@
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 fn start(c: comm::chan<comm::chan<str>>) {
     let p = comm::port();

src/test/run-pass/task-comm-11.rs

@@ -1,6 +1,6 @@
 use std;
-import std::comm;
-import std::task;
+import comm;
+import task;
 
 fn start(c: comm::chan<comm::chan<int>>) {
     let p: comm::port<int> = comm::port();

src/test/run-pass/task-comm-12.rs

@@ -1,5 +1,5 @@
 use std;
-import std::task;
+import task;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-13.rs

@@ -1,7 +1,7 @@
 use std;
-import std::task;
-import std::comm;
-import std::comm::send;
+import task;
+import comm;
+import comm::send;
 
 fn start(&&args: (comm::chan<int>, int, int)) {
     let (c, start, number_of_messages) = args;

src/test/run-pass/task-comm-14.rs

@@ -1,6 +1,6 @@
 use std;
-import std::comm;
-import std::task;
+import comm;
+import task;
 
 fn main() {
     let po = comm::port::<int>();

src/test/run-pass/task-comm-15.rs

@@ -1,7 +1,7 @@
 // xfail-win32
 use std;
-import std::comm;
-import std::task;
+import comm;
+import task;
 
 fn start(&&args: (comm::chan<int>, int)) {
     let (c, i) = args;

src/test/run-pass/task-comm-16.rs

@@ -1,11 +1,11 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
-import std::comm::send;
-import std::comm::port;
-import std::comm::recv;
-import std::comm::chan;
+import comm;
+import comm::send;
+import comm::port;
+import comm::recv;
+import comm::chan;
 
 // Tests of ports and channels on various types
 fn test_rec() {

src/test/run-pass/task-comm-17.rs

@@ -6,7 +6,7 @@
 // until such time as we have unique closures.
 
 use std;
-import std::task;
+import task;
 
 fn f() {
 }

src/test/run-pass/task-comm-2.rs

@@ -1,7 +1,7 @@
 // xfail-win32
 use std;
 
-import std::task;
+import task;
 
 fn main() { log "===== SPAWNING and JOINING THREAD TASKS ====="; test00(); }
 

src/test/run-pass/task-comm-3.rs

@@ -1,9 +1,9 @@
 use std;
-import std::task;
-import std::comm;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::recv;
+import task;
+import comm;
+import comm::chan;
+import comm::send;
+import comm::recv;
 
 fn main() { log "===== WITHOUT THREADS ====="; test00(); }
 

src/test/run-pass/task-comm-4.rs

@@ -1,6 +1,6 @@
 use std;
-import std::comm;
-import std::comm::send;
+import comm;
+import comm::send;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-5.rs

@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-6.rs

@@ -1,6 +1,6 @@
 use std;
-import std::comm;
-import std::comm::send;
+import comm;
+import comm::send;
 import comm::chan;
 import comm::recv;
 

src/test/run-pass/task-comm-7.rs

@@ -1,6 +1,6 @@
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 import comm::chan;
 import comm::recv;
 import comm::port;

src/test/run-pass/task-comm-8.rs

@@ -1,6 +1,6 @@
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-9.rs

@@ -1,6 +1,6 @@
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 fn main() { test00(); }
 

src/test/run-pass/task-comm-chan-cleanup.rs

@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() {
     let p = comm::port();

src/test/run-pass/task-comm-chan-cleanup2.rs

@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() {
     let p = comm::port();

src/test/run-pass/task-comm-chan-cleanup3.rs

@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() {
     let c = {

src/test/run-pass/task-comm-chan-cleanup4.rs

@@ -1,12 +1,12 @@
 use std;
-import std::int;
-import std::comm;
-import std::task;
+import int;
+import comm;
+import task;
 
 // We're trying to trigger a race between send and port destruction that
 // results in the string not being freed
 
-fn starship(&&ch: std::comm::chan<str>) {
+fn starship(&&ch: comm::chan<str>) {
     int::range(0, 10) { |_i|
         comm::send(ch, "pew pew");
     }

src/test/run-pass/task-comm-chan-nil.rs

@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std::comm;
+import comm;
 
 // rustboot can't transmit nils across channels because they don't have
 // any size, but rustc currently can because they do have size. Whether

src/test/run-pass/task-comm.rs

@@ -1,12 +1,12 @@
 use std;
 
-import std::task;
-import std::task::task;
-import std::comm;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::send;
-import std::comm::recv;
+import task;
+import task::task;
+import comm;
+import comm::chan;
+import comm::port;
+import comm::send;
+import comm::recv;
 
 fn main() {
     test00();

src/test/run-pass/task-compare.rs

@@ -6,9 +6,9 @@
 // xfail-test
 
 use std;
-import std::task;
-import std::task::join;
-import std::comm;
+import task;
+import task::join;
+import comm;
 
 fn child() { }
 

src/test/run-pass/task-killjoin.rs

@@ -7,7 +7,7 @@
 // the supervised task exits.
 
 use std;
-import std::task;
+import task;
 
 fn supervised(&&_args: ()) {
     // Yield to make sure the supervisor joins before we

src/test/run-pass/task-life-0.rs

@@ -1,5 +1,5 @@
 use std;
-import std::task;
+import task;
 fn main() { task::spawn("Hello", child); }
 
 fn child(&&s: str) {

src/test/run-pass/task-pin.rs

@@ -5,6 +5,6 @@
 
 use std;
 
-import std::task;
+import task;
 
 fn main() { task::pin(); task::unpin(); }

src/test/run-pass/terminate-in-initializer.rs

@@ -11,14 +11,14 @@ fn test_cont() { let i = 0; while i < 1 { i += 1; let x: @int = cont; } }
 fn test_ret() { let x: @int = ret; }
 
 fn test_fail() {
-    fn f(&&_i: ()) { std::task::unsupervise(); let x: @int = fail; }
-    std::task::spawn((), f);
+    fn f(&&_i: ()) { task::unsupervise(); let x: @int = fail; }
+    task::spawn((), f);
 }
 
 fn test_fail_indirect() {
     fn f() -> ! { fail; }
-    fn g(&&_i: ()) { std::task::unsupervise(); let x: @int = f(); }
-    std::task::spawn((), g);
+    fn g(&&_i: ()) { task::unsupervise(); let x: @int = f(); }
+    task::spawn((), g);
 }
 
 fn main() {

src/test/run-pass/test-ignore-cfg.rs

@@ -3,8 +3,8 @@
 // xfail-pretty
 
 use std;
-import std::option;
-import std::vec;
+import option;
+import vec;
 
 #[test]
 #[ignore(cfg(ignorecfg))]

src/test/run-pass/threads.rs

@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std::task;
+import task;
 
 fn main() {
     let i = 10;