Copy first batch of material from libstd to libcore.

author: Graydon Hoare <graydon@mozilla.com> 2011-12-13 16:25:51 -0800
committer: Graydon Hoare <graydon@mozilla.com> 2011-12-13 16:34:50 -0800
commit: fa9ad984fb2f013baebdbe01a42baa3b9101dd84 (patch)
tree: 49115690e45ca322337b93f25308cd618f85b013 /src/test
parent: 32087f5c2a35bf8050067c22a57fd60269633a60 (diff)
download: rust-fa9ad984fb2f013baebdbe01a42baa3b9101dd84.tar.gz
rust-fa9ad984fb2f013baebdbe01a42baa3b9101dd84.zip
204 files changed, 532 insertions, 462 deletions
diff --git a/src/test/bench/99bob-iter.rs b/src/test/bench/99bob-iter.rs
index c41f57369fa..500cb44758c 100644
--- a/src/test/bench/99bob-iter.rs
+++ b/src/test/bench/99bob-iter.rs
@@ -5,8 +5,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::int;
-import std::str;
+import int;
+import str;
 
 fn b1() -> str { ret "# of beer on the wall, # of beer."; }
 
diff --git a/src/test/bench/99bob-pattern.rs b/src/test/bench/99bob-pattern.rs
index fdfce9dfae5..4feeda28b1b 100644
--- a/src/test/bench/99bob-pattern.rs
+++ b/src/test/bench/99bob-pattern.rs
@@ -5,8 +5,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::int;
-import std::str;
+import int;
+import str;
 
 tag bottle { none; dual; single; multiple(int); }
 
diff --git a/src/test/bench/99bob-simple.rs b/src/test/bench/99bob-simple.rs
index 2db6321d257..ac21780a62d 100644
--- a/src/test/bench/99bob-simple.rs
+++ b/src/test/bench/99bob-simple.rs
@@ -5,8 +5,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::int;
-import std::str;
+import int;
+import str;
 
 fn b1() -> str { ret "# of beer on the wall, # of beer."; }
 
diff --git a/src/test/bench/99bob-tail.rs b/src/test/bench/99bob-tail.rs
index af5e22f48ea..b4c50a87809 100644
--- a/src/test/bench/99bob-tail.rs
+++ b/src/test/bench/99bob-tail.rs
@@ -3,8 +3,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::int;
-import std::str;
+import int;
+import str;
 
 fn main() {
     fn multiple(n: int) {
diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs
index d6a44e6eb82..213ee46c0ec 100644
--- a/src/test/bench/shootout-binarytrees.rs
+++ b/src/test/bench/shootout-binarytrees.rs
@@ -1,5 +1,5 @@
 use std;
-import std::int;
+import int;
 
 tag tree { nil; node(@tree, @tree, int); }
 
diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs
index 8e7b2cbe269..ea9f8341d4d 100644
--- a/src/test/bench/shootout-fannkuchredux.rs
+++ b/src/test/bench/shootout-fannkuchredux.rs
@@ -1,7 +1,7 @@
 // Based on Isaac Gouy's fannkuchredux.csharp
 use std;
-import std::int;
-import std::vec;
+import int;
+import vec;
 
 fn fannkuch(n: int) -> int {
     fn perm1init(i: uint) -> int { ret i as int; }
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index db9905280b7..d8bba3d0725 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -6,10 +6,10 @@
  * http://shootout.alioth.debian.org/
  */
 use std;
-import std::vec;
-import std::uint;
-import std::int;
-import std::str;
+import vec;
+import uint;
+import int;
+import str;
 
 fn LINE_LENGTH() -> uint { ret 60u; }
 
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index fb078dea17d..482d4e05d51 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -12,20 +12,20 @@
 
 use std;
 
-import std::vec;
-import std::uint;
+import vec;
+import uint;
 import std::time;
-import std::str;
-import std::int::range;
+import str;
+import int::range;
 import std::io;
 import std::getopts;
-import std::task;
-import std::u64;
-import std::comm;
-import std::comm::port;
-import std::comm::chan;
-import std::comm::send;
-import std::comm::recv;
+import task;
+import u64;
+import comm;
+import comm::port;
+import comm::chan;
+import comm::send;
+import comm::recv;
 
 fn fib(n: int) -> int {
     fn pfib(args: (chan<int>, int)) {
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 51338605a82..4d8e289af88 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -1,10 +1,10 @@
 use std;
 
 import std::io;
-import std::str;
-import std::uint;
-import std::u8;
-import std::vec;
+import str;
+import uint;
+import u8;
+import vec;
 import std::bitv;
 
 // Computes a single solution to a given 9x9 sudoku
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index 8e12bc7edee..3b9b9a0a05b 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -1,8 +1,8 @@
 use std;
-import std::vec;
-import std::task;
-import std::uint;
-import std::str;
+import vec;
+import task;
+import uint;
+import str;
 
 fn f(&&n: uint) {
     let i = 0u;
diff --git a/src/test/bench/task-perf-vector-party.rs b/src/test/bench/task-perf-vector-party.rs
index c61af8dd0de..b5d7fbf24a0 100644
--- a/src/test/bench/task-perf-vector-party.rs
+++ b/src/test/bench/task-perf-vector-party.rs
@@ -4,10 +4,10 @@
 // allocating and freeing vectors.
 
 use std;
-import std::vec;
-import std::uint;
-import std::str;
-import std::task;
+import vec;
+import uint;
+import str;
+import task;
 
 fn f(&&n: uint) {
     uint::range(0u, n) {|i|
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 5f6c1e92309..94358e23945 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -12,24 +12,24 @@
 
 use std;
 
-import option = std::option::t;
-import std::option::some;
-import std::option::none;
-import std::str;
+import option = option::t;
+import option::some;
+import option::none;
+import str;
 import std::treemap;
-import std::vec;
+import vec;
 import std::io;
 
 import std::time;
-import std::u64;
-
-import std::task;
-import std::task::joinable_task;
-import std::comm;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::recv;
-import std::comm::send;
+import u64;
+
+import task;
+import task::joinable_task;
+import comm;
+import comm::chan;
+import comm::port;
+import comm::recv;
+import comm::send;
 
 fn map(&&filename: [u8], emit: map_reduce::putter<[u8], int>) {
     let f = io::file_reader(str::unsafe_from_bytes(filename));
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index d0309713633..b4637eacdd1 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -10,25 +10,25 @@
 
 use std;
 
-import option = std::option::t;
-import std::option::some;
-import std::option::none;
-import std::str;
+import option = option::t;
+import option::some;
+import option::none;
+import str;
 import std::map;
-import std::vec;
+import vec;
 import std::io;
 
 import std::time;
-import std::u64;
-import std::result;
-
-import std::task;
-import std::task::joinable_task;
-import std::comm;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::recv;
-import std::comm::send;
+import u64;
+import result;
+
+import task;
+import task::joinable_task;
+import comm;
+import comm::chan;
+import comm::port;
+import comm::recv;
+import comm::send;
 
 fn map(input: str, emit: map_reduce::putter) {
     let f = io::string_reader(input);
diff --git a/src/test/compile-fail/bad-module.rs b/src/test/compile-fail/bad-module.rs
index e0b350d4b49..662e3108bf0 100644
--- a/src/test/compile-fail/bad-module.rs
+++ b/src/test/compile-fail/bad-module.rs
@@ -1,4 +1,4 @@
 // error-pattern: unresolved import
-import vec;
+import thing;
 
-fn main() { let foo = vec::len([]); }
+fn main() { let foo = thing::len([]); }
diff --git a/src/test/compile-fail/cross-crate-glob-collision.rs b/src/test/compile-fail/cross-crate-glob-collision.rs
index 490f8ae9b21..8c40cd3e25d 100644
--- a/src/test/compile-fail/cross-crate-glob-collision.rs
+++ b/src/test/compile-fail/cross-crate-glob-collision.rs
@@ -3,7 +3,7 @@
 
 use std;
 // expecting swap to be defined in vec
-import std::vec::*;
+import vec::*;
 import alternate_supplier::*;
 
 mod alternate_supplier {
diff --git a/src/test/compile-fail/fn-constraint.rs b/src/test/compile-fail/fn-constraint.rs
index bd6cd7b8ff1..3b9221587ac 100644
--- a/src/test/compile-fail/fn-constraint.rs
+++ b/src/test/compile-fail/fn-constraint.rs
@@ -1,6 +1,6 @@
 // error-pattern:precondition constraint (for example, uint::le(a, b)
 use std;
-import std::str::*;
+import str::*;
 
 fn main() {
     let a: uint = 4u;
diff --git a/src/test/compile-fail/mutable-huh-ptr-assign.rs b/src/test/compile-fail/mutable-huh-ptr-assign.rs
index 46f1ceee15d..8d6b9565333 100644
--- a/src/test/compile-fail/mutable-huh-ptr-assign.rs
+++ b/src/test/compile-fail/mutable-huh-ptr-assign.rs
@@ -10,7 +10,7 @@ fn main() {
 
     unsafe {
         let a = 0;
-        let v = std::ptr::mut_addr_of(a);
+        let v = ptr::mut_addr_of(a);
         f(v);
     }
 }
diff --git a/src/test/compile-fail/mutable-huh-variance-ptr.rs b/src/test/compile-fail/mutable-huh-variance-ptr.rs
index 0cb05af444c..f735af5ba73 100644
--- a/src/test/compile-fail/mutable-huh-variance-ptr.rs
+++ b/src/test/compile-fail/mutable-huh-variance-ptr.rs
@@ -4,7 +4,7 @@ use std;
 
 fn main() {
     let a = [0];
-    let v: *mutable [int] = std::ptr::mut_addr_of(a);
+    let v: *mutable [int] = ptr::mut_addr_of(a);
 
     fn f(&&v: *mutable [const int]) {
         unsafe {
diff --git a/src/test/compile-fail/no-constraint-prop.rs b/src/test/compile-fail/no-constraint-prop.rs
index 65e21baf78b..59f5b8435d1 100644
--- a/src/test/compile-fail/no-constraint-prop.rs
+++ b/src/test/compile-fail/no-constraint-prop.rs
@@ -1,7 +1,7 @@
 // error-pattern:Unsatisfied precondition constraint (for example, le(b, d
 use std;
-import std::str::*;
-import std::uint::*;
+import str::*;
+import uint::*;
 
 fn main() {
     let a: uint = 1u;
diff --git a/src/test/compile-fail/non-triv-cast-be.rs b/src/test/compile-fail/non-triv-cast-be.rs
index 14f2c0bfdcd..74a0e4da288 100644
--- a/src/test/compile-fail/non-triv-cast-be.rs
+++ b/src/test/compile-fail/non-triv-cast-be.rs
@@ -1,7 +1,7 @@
 // error-pattern: non-trivial cast of tail-call return value
 use std;
 
-import std::ctypes::*;
+import ctypes::*;
 
 fn foo_float() -> m_float { ret 0.0 as m_float; }
 fn bar_float() -> bool { be foo_float() as bool; }
diff --git a/src/test/compile-fail/nonsense-constraints.rs b/src/test/compile-fail/nonsense-constraints.rs
index 47809cdcaf2..b7c5614f176 100644
--- a/src/test/compile-fail/nonsense-constraints.rs
+++ b/src/test/compile-fail/nonsense-constraints.rs
@@ -1,7 +1,7 @@
 // Tests that the typechecker checks constraints
 // error-pattern:mismatched types: expected uint but found u8
 use std;
-import std::uint;
+import uint;
 
 fn enum_chars(start: u8, end: u8) : uint::le(start, end) -> [char] {
     let i = start;
diff --git a/src/test/compile-fail/pattern-tyvar-2.rs b/src/test/compile-fail/pattern-tyvar-2.rs
index ead40e3948e..cfc85d86e21 100644
--- a/src/test/compile-fail/pattern-tyvar-2.rs
+++ b/src/test/compile-fail/pattern-tyvar-2.rs
@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 use std;
-import std::option;
-import std::option::some;
+import option;
+import option::some;
 
 // error-pattern: mismatched types
 
diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index 107ebf2c7b6..705a662e14d 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 use std;
-import std::option;
-import std::option::some;
+import option;
+import option::some;
 
 // error-pattern: mismatched types
 
diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs
index ef7cf1d8cc0..e517be752e6 100644
--- a/src/test/compile-fail/spawn-non-nil-fn.rs
+++ b/src/test/compile-fail/spawn-non-nil-fn.rs
@@ -1,7 +1,7 @@
 // error-pattern: mismatched types
 
 use std;
-import std::task;
+import task;
 
 fn f(&&x: int) -> int { ret x; }
 
diff --git a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
index b7dfa1dbc4c..0c0ea02164c 100644
--- a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
+++ b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
@@ -2,7 +2,7 @@
 // xfail-test
 // error-pattern:option::t
 use std;
-import std::vec::*;
+import vec::*;
 
 fn main() {
     let y;
diff --git a/src/test/compile-fail/zip-missing-check.rs b/src/test/compile-fail/zip-missing-check.rs
index 51028a03623..dac5b6d7e8f 100644
--- a/src/test/compile-fail/zip-missing-check.rs
+++ b/src/test/compile-fail/zip-missing-check.rs
@@ -1,8 +1,8 @@
 // error-pattern:Unsatisfied precondition constraint (for example, same_length
 use std;
-import std::uint;
-import std::u8;
-import std::vec::*;
+import uint;
+import u8;
+import vec::*;
 
 fn main() {
     let a = 'a' as u8, j = 'j' as u8, k = 1u, l = 10u;
diff --git a/src/test/run-fail/alt-bot-fail.rs b/src/test/run-fail/alt-bot-fail.rs
index 355892d5a13..1a4155574f8 100644
--- a/src/test/run-fail/alt-bot-fail.rs
+++ b/src/test/run-fail/alt-bot-fail.rs
@@ -2,7 +2,7 @@
 
 // error-pattern:explicit failure
 use std;
-import std::option::*;
+import option::*;
 
 fn foo(s: str) { }
 
diff --git a/src/test/run-fail/fail-main.rs b/src/test/run-fail/fail-main.rs
index a8e51009352..5df6d09896e 100644
--- a/src/test/run-fail/fail-main.rs
+++ b/src/test/run-fail/fail-main.rs
@@ -1,4 +1,4 @@
 // error-pattern:moop
 use std;
-import std::uint;
+import uint;
 fn main() { fail "moop"; }
diff --git a/src/test/run-fail/fn-constraint-claim.rs b/src/test/run-fail/fn-constraint-claim.rs
index d126b7e9318..5a5fa5ea81c 100644
--- a/src/test/run-fail/fn-constraint-claim.rs
+++ b/src/test/run-fail/fn-constraint-claim.rs
@@ -1,6 +1,6 @@
 // error-pattern:quux
 use std;
-import std::uint::*;
+import uint::*;
 
 fn nop(a: uint, b: uint) : le(a, b) { fail "quux"; }
 
diff --git a/src/test/run-fail/fn-constraint.rs b/src/test/run-fail/fn-constraint.rs
index 3499d44ceff..87d082c47a9 100644
--- a/src/test/run-fail/fn-constraint.rs
+++ b/src/test/run-fail/fn-constraint.rs
@@ -1,7 +1,7 @@
 // error-pattern:Predicate le(a, b) failed
 use std;
-import std::str::*;
-import std::uint::le;
+import str::*;
+import uint::le;
 
 fn main() {
     let a: uint = 4u;
diff --git a/src/test/run-fail/for-each-loop-fail.rs b/src/test/run-fail/for-each-loop-fail.rs
index 2ee17ede769..cdb054a4e8d 100644
--- a/src/test/run-fail/for-each-loop-fail.rs
+++ b/src/test/run-fail/for-each-loop-fail.rs
@@ -1,4 +1,4 @@
 // error-pattern:moop
 use std;
-import std::uint;
+import uint;
 fn main() { uint::range(0u, 10u) {|_i| fail "moop"; } }
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index d11dc4147ef..0baa9fd9098 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -2,9 +2,9 @@
 
 // error-pattern:1 == 2
 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); }
 
diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index 1bdea315151..a52c1fed1ca 100644
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -2,10 +2,10 @@
 
 // error-pattern:fail
 use std;
-import std::task;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import comm::chan;
+import comm::port;
+import comm::recv;
 
 fn child(&&_i: ()) { fail; }
 
diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index 60835697408..b24c6d8a6cf 100644
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -2,9 +2,9 @@
 
 // error-pattern:fail
 use std;
-import std::task;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import comm::port;
+import comm::recv;
 
 fn grandchild(&&_i: ()) { fail; }
 
diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index 2e8861dcd3f..ef544778d43 100644
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -1,10 +1,10 @@
 // -*- rust -*-
 // error-pattern:1 == 2
 use std;
-import std::task;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::recv;
+import task;
+import comm::chan;
+import comm::port;
+import comm::recv;
 
 fn child(&&_args: ()) { assert (1 == 2); }
 
diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs
index b47108ba026..25170db40e4 100644
--- a/src/test/run-fail/morestack2.rs
+++ b/src/test/run-fail/morestack2.rs
@@ -34,7 +34,7 @@ resource and_then_get_big_again(_i: ()) {
 
 fn main() {
     rustrt::set_min_stack(1024u);
-    std::task::spawn((), fn (&&_i: ()) {
+    task::spawn((), fn (&&_i: ()) {
         let r = and_then_get_big_again(());
         getbig_call_c_and_fail(10000);
     });
diff --git a/src/test/run-fail/morestack3.rs b/src/test/run-fail/morestack3.rs
index 93faea60a52..e1a77bee9b6 100644
--- a/src/test/run-fail/morestack3.rs
+++ b/src/test/run-fail/morestack3.rs
@@ -30,5 +30,5 @@ resource and_then_get_big_again(_i: @int) {
 
 fn main() {
     rustrt::set_min_stack(1024u);
-    std::task::spawn(400, getbig_and_fail);
+    task::spawn(400, getbig_and_fail);
 }
\ No newline at end of file
diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs
index e227b3d4c93..a43c7ce0e69 100644
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -1,9 +1,9 @@
 // error-pattern:meep
 use std;
-import std::comm::chan;
-import std::comm::port;
-import std::comm::send;
-import std::comm::recv;
+import comm::chan;
+import comm::port;
+import comm::send;
+import comm::recv;
 
 fn echo<send T>(c: chan<T>, oc: chan<chan<T>>) {
     // Tests that the type argument in port gets
diff --git a/src/test/run-fail/spawnfail.rs b/src/test/run-fail/spawnfail.rs
index a4fcffb43f7..87cf90fc69d 100644
--- a/src/test/run-fail/spawnfail.rs
+++ b/src/test/run-fail/spawnfail.rs
@@ -1,7 +1,7 @@
 // xfail-win32
 // error-pattern:explicit
 use std;
-import std::task;
+import task;
 
 // We don't want to see any invalid reads
 fn main() {
diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index c79fa33cf73..314921cdfb7 100644
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -1,8 +1,8 @@
 // error-pattern:goodfail
 
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 fn goodfail(&&_i: ()) {
     task::yield();
diff --git a/src/test/run-fail/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs
index 811eff881ae..365a1cbdcc6 100644
--- a/src/test/run-fail/unwind-misc-1.rs
+++ b/src/test/run-fail/unwind-misc-1.rs
@@ -2,12 +2,12 @@
 
 use std;
 import std::map;
-import std::uint;
+import uint;
 
 fn main() {
     let count = @mutable 0u;
     fn hash(&&s: [@str]) -> uint {
-        if (std::vec::len(s) > 0u && std::str::eq(*s[0], "boom")) { fail; }
+        if (vec::len(s) > 0u && str::eq(*s[0], "boom")) { fail; }
         ret 10u;
     }
     fn eq(&&s: [@str], &&t: [@str]) -> bool {
diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs
index dcc86fdd3c9..04ab5bf8d9d 100644
--- a/src/test/run-fail/zip-different-lengths.rs
+++ b/src/test/run-fail/zip-different-lengths.rs
@@ -2,9 +2,9 @@
 // the check should fail at runtime
 // error-pattern:Predicate same_length
 use std;
-import std::uint;
-import std::u8;
-import std::vec::*;
+import uint;
+import u8;
+import vec::*;
 
 fn main() {
     let a = 'a' as u8, j = 'j' as u8, k = 1u, l = 9u;
diff --git a/src/test/run-pass/acyclic-unwind.rs b/src/test/run-pass/acyclic-unwind.rs
index 28a1e9d6708..0b6b58fee26 100644
--- a/src/test/run-pass/acyclic-unwind.rs
+++ b/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};
diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs
index 9b7e0001f3c..37186537d6c 100644
--- a/src/test/run-pass/alias-uninit-value.rs
+++ b/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; }
 
diff --git a/src/test/run-pass/alt-bot.rs b/src/test/run-pass/alt-bot.rs
index 6949d727f59..27389ebdd23 100644
--- a/src/test/run-pass/alt-bot.rs
+++ b/src/test/run-pass/alt-bot.rs
@@ -1,5 +1,5 @@
 use std;
-import std::option::*;
+import option::*;
 
 fn main() {
     let i: int =
diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index e6cf1dec958..6b2ae3ffa9c 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/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;
diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs
index 9705e902d6a..ec6b45cef01 100644
--- a/src/test/run-pass/basic-1.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs
index 228c4f96dbb..b1de773f02d 100644
--- a/src/test/run-pass/basic-2.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index 2547b48f8a5..e162b3aba85 100644
--- a/src/test/run-pass/basic.rs
+++ b/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 {
diff --git a/src/test/run-pass/bind-native-fn.rs b/src/test/run-pass/bind-native-fn.rs
index 29d908e8c0b..aab3ba2dc75 100644
--- a/src/test/run-pass/bind-native-fn.rs
+++ b/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);
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index c627d28e52b..3eedf7f48ca 100644
--- a/src/test/run-pass/binops.rs
+++ b/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 (() == ());
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index da677abebac..9ffed2ff64a 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/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]);
diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs
index 9d1536c0ce7..879db89b713 100644
--- a/src/test/run-pass/c-stack-returning-int64.rs
+++ b/src/test/run-pass/c-stack-returning-int64.rs
@@ -1,5 +1,5 @@
 use std;
-import std::str;
+import str;
 
 #[abi = "cdecl"]
 #[link_name = ""]
diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index b6230986272..171947050d8 100644
--- a/src/test/run-pass/chan-leak.rs
+++ b/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>); }
 
diff --git a/src/test/run-pass/check-pattern-bound.rs b/src/test/run-pass/check-pattern-bound.rs
index 32c6ac2475b..ad820c3c683 100644
--- a/src/test/run-pass/check-pattern-bound.rs
+++ b/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 }
 
diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs
index 95c70bc7a7b..04940947145 100644
--- a/src/test/run-pass/child-outlives-parent.rs
+++ b/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) { }
 
diff --git a/src/test/run-pass/claim-nonterm.rs b/src/test/run-pass/claim-nonterm.rs
index 3ef1584770b..5f427d185eb 100644
--- a/src/test/run-pass/claim-nonterm.rs
+++ b/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; }
 
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
index 2512b84e5dc..7278e4ac994 100644
--- a/src/test/run-pass/clone-with-exterior.rs
+++ b/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);
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index 2de0d0e4c90..0962a182acd 100644
--- a/src/test/run-pass/comm.rs
+++ b/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();
diff --git a/src/test/run-pass/constraint-prop-expr-move.rs b/src/test/run-pass/constraint-prop-expr-move.rs
index 56ebc914b93..a83ef3e6f55 100644
--- a/src/test/run-pass/constraint-prop-expr-move.rs
+++ b/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;
diff --git a/src/test/run-pass/constraint-prop-move.rs b/src/test/run-pass/constraint-prop-move.rs
index 97285adae0c..b551a0653d0 100644
--- a/src/test/run-pass/constraint-prop-move.rs
+++ b/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;
diff --git a/src/test/run-pass/constraint-prop-swap.rs b/src/test/run-pass/constraint-prop-swap.rs
index 7b96a89bb16..45d04643627 100644
--- a/src/test/run-pass/constraint-prop-swap.rs
+++ b/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;
diff --git a/src/test/run-pass/constraint-prop.rs b/src/test/run-pass/constraint-prop.rs
index 71f151f5260..e2e486cbd49 100644
--- a/src/test/run-pass/constraint-prop.rs
+++ b/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;
diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs
index 72ae74c04ce..7cee261e1cb 100644
--- a/src/test/run-pass/decl-with-recv.rs
+++ b/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();
diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs
index c27b97d81da..f610bb0bf69 100644
--- a/src/test/run-pass/float-nan.rs
+++ b/src/test/run-pass/float-nan.rs
@@ -1,5 +1,5 @@
 use std;
-import std::float;
+import float;
 
 fn main() {
   let nan = float::NaN;
diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs
index d575758fd62..00ee9f89140 100644
--- a/src/test/run-pass/fn-bare-size.rs
+++ b/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>();
 }
\ No newline at end of file
diff --git a/src/test/run-pass/fn-constraint.rs b/src/test/run-pass/fn-constraint.rs
index f9ea572a735..0a7db451cfb 100644
--- a/src/test/run-pass/fn-constraint.rs
+++ b/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;
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index cb43371b3c6..32bcecc5ee3 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/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"); }
 
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index fca6c1d61bd..7646028eb25 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/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);
diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index fae30afa4ad..534e00f4f5d 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/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]));
     {
diff --git a/src/test/run-pass/infinite-loops.rs b/src/test/run-pass/infinite-loops.rs
index 3c2be61ac65..4eae0601d03 100644
--- a/src/test/run-pass/infinite-loops.rs
+++ b/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;
diff --git a/src/test/run-pass/invoke-external-native.rs b/src/test/run-pass/invoke-external-native.rs
index ec31a0ec100..d337f3c0942 100644
--- a/src/test/run-pass/invoke-external-native.rs
+++ b/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
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 35d21e40be2..eb75139b4a3 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/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,
diff --git a/src/test/run-pass/issue-506.rs b/src/test/run-pass/issue-506.rs
index 28f1a92bbf8..b1feb5df68e 100644
--- a/src/test/run-pass/issue-506.rs
+++ b/src/test/run-pass/issue-506.rs
@@ -8,7 +8,7 @@
 */
 
 use std;
-import std::task;
+import task;
 
 #[abi = "cdecl"]
 native mod rustrt {
diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index 8a3339a065c..e10048d850f 100644
--- a/src/test/run-pass/issue-507.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/issue-511.rs b/src/test/run-pass/issue-511.rs
index b843d42570b..36b2e65897e 100644
--- a/src/test/run-pass/issue-511.rs
+++ b/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;
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 4827c428aa1..c23411d88ca 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/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]); }
 
diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs
index f43e7ebb00a..086e6529320 100644
--- a/src/test/run-pass/issue-783.rs
+++ b/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() {
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index 09bb40295ea..41b06d9294c 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/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,
diff --git a/src/test/run-pass/join.rs b/src/test/run-pass/join.rs
index bbbbcb8045b..afcb43edfbe 100644
--- a/src/test/run-pass/join.rs
+++ b/src/test/run-pass/join.rs
@@ -2,7 +2,7 @@
 
 use std;
 
-import std::task::*;
+import task::*;
 
 fn main() {
     let other = spawn_joinable((), child);
diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 3102a66a192..80687497366 100644
--- a/src/test/run-pass/lazychan.rs
+++ b/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();
diff --git a/src/test/run-pass/linked-failure.rs b/src/test/run-pass/linked-failure.rs
index 054218c2837..7e9b1571efe 100644
--- a/src/test/run-pass/linked-failure.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/lots-a-fail.rs b/src/test/run-pass/lots-a-fail.rs
index 155a9ff9cc2..f2f83a9b3d9 100644
--- a/src/test/run-pass/lots-a-fail.rs
+++ b/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;
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index f344451e662..e8c6ae14fa1 100644
--- a/src/test/run-pass/many.rs
+++ b/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;
diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs
index b561f84c4b8..1f7bd05a7ab 100644
--- a/src/test/run-pass/mlist-cycle.rs
+++ b/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()};
 }
\ No newline at end of file
diff --git a/src/test/run-pass/mod-view-items.rs b/src/test/run-pass/mod-view-items.rs
index 8e10eb4b710..c83a6e53ebb 100644
--- a/src/test/run-pass/mod-view-items.rs
+++ b/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) }
 }
 
diff --git a/src/test/run-pass/morestack5.rs b/src/test/run-pass/morestack5.rs
index bedf3f47ee9..b05e0f85539 100644
--- a/src/test/run-pass/morestack5.rs
+++ b/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);
diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs
index ef1a87aeea6..c8e88ac7cdd 100644
--- a/src/test/run-pass/morestack6.rs
+++ b/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 {
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index 328fba83d7a..13ff41ba3fb 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/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;
diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs
index 55f94de60b4..eb1e125725c 100644
--- a/src/test/run-pass/move-3.rs
+++ b/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;
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 27fedd2222f..1fffce98e52 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/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;
diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs
index 76a4fa00924..aaaf05938a8 100644
--- a/src/test/run-pass/move-4.rs
+++ b/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;
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 334c8baed4f..942efdadc06 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/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);
 }
diff --git a/src/test/run-pass/native-fn-linkname.rs b/src/test/run-pass/native-fn-linkname.rs
index 785ec5edda5..98f429f8cb0 100644
--- a/src/test/run-pass/native-fn-linkname.rs
+++ b/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"]
diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs
index aa91eeeb00a..9ca73209f36 100644
--- a/src/test/run-pass/nested-alts.rs
+++ b/src/test/run-pass/nested-alts.rs
@@ -1,6 +1,6 @@
 
 use std;
-import std::option::*;
+import option::*;
 
 fn baz() -> ! { fail; }
 
diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs
index 8072378b581..cf19630146f 100644
--- a/src/test/run-pass/nested-pattern.rs
+++ b/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>); }
 
diff --git a/src/test/run-pass/obj-docs.rs b/src/test/run-pass/obj-docs.rs
index f08897a2fa3..3da7f5a29fa 100644
--- a/src/test/run-pass/obj-docs.rs
+++ b/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() {
 
diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs
index 244a92dea0f..d09f04cc92f 100644
--- a/src/test/run-pass/pattern-bound-var-in-for-each.rs
+++ b/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) {
 
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index aa5154c9ffb..ed40fec9e77 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/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};
diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs
index 0d54c028578..b119ac6eb1d 100644
--- a/src/test/run-pass/send-iloop.rs
+++ b/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;
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index aad9a0696d1..1c88d0182f6 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/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};
diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
index c34f2cf6636..0d427dca45f 100644
--- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
+++ b/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 {
 
diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs
index f77a5dc4d1d..df64e47bbf8 100644
--- a/src/test/run-pass/spawn-fn.rs
+++ b/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;
diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index f04a4f8d8c7..66ca0363472 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index 70276916e89..fe6ea6374b1 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/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>;
 
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index a92e4659382..cc540efa2af 100644
--- a/src/test/run-pass/spawn.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 16813eafe7f..fa07cfecf58 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/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); }
 
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index e1fa92738cb..4e117c4baa2 100644
--- a/src/test/run-pass/str-append.rs
+++ b/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";
diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs
index 15a13083321..6523ce47df3 100644
--- a/src/test/run-pass/str-multiline.rs
+++ b/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 \
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index 94a9696adf0..d65cfcbf4a9 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/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.
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 93e18580c64..66192aac5aa 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/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;
diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs
index e40f2c3d881..abd4819b3bd 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index eb0e0819ed6..970e885e673 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 12146aff535..61017a994fc 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/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();
diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs
index 218ab723144..d8f3d12d059 100644
--- a/src/test/run-pass/task-comm-11.rs
+++ b/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();
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index ca82b1614ae..bd4c8a64418 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -1,5 +1,5 @@
 use std;
-import std::task;
+import task;
 
 fn main() { test00(); }
 
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index d0f59698650..a9d63c70237 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/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;
diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index fda04fbe7fd..6bf0fe89abd 100644
--- a/src/test/run-pass/task-comm-14.rs
+++ b/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>();
diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs
index 69b11519d28..c526f54203d 100644
--- a/src/test/run-pass/task-comm-15.rs
+++ b/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;
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index e6e253ef9bb..f1c83487c72 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/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() {
diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs
index 52d84d90dfc..eb6ab003417 100644
--- a/src/test/run-pass/task-comm-17.rs
+++ b/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() {
 }
diff --git a/src/test/run-pass/task-comm-2.rs b/src/test/run-pass/task-comm-2.rs
index 239f636a72f..84033d3c101 100644
--- a/src/test/run-pass/task-comm-2.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 18f14dd15a4..7a193819756 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs
index a0b0195aadc..bc30f2e4e7d 100644
--- a/src/test/run-pass/task-comm-4.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs
index ae966834d2b..bbae3f343a8 100644
--- a/src/test/run-pass/task-comm-5.rs
+++ b/src/test/run-pass/task-comm-5.rs
@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() { test00(); }
 
diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs
index d01a81a3658..63575109165 100644
--- a/src/test/run-pass/task-comm-6.rs
+++ b/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;
 
diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs
index 2b7bcb37118..07b82a17987 100644
--- a/src/test/run-pass/task-comm-7.rs
+++ b/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;
diff --git a/src/test/run-pass/task-comm-8.rs b/src/test/run-pass/task-comm-8.rs
index 69202c286f7..bd2cc06cd4b 100644
--- a/src/test/run-pass/task-comm-8.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index 86c58cfbe70..b020118ed8a 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/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(); }
 
diff --git a/src/test/run-pass/task-comm-chan-cleanup.rs b/src/test/run-pass/task-comm-chan-cleanup.rs
index 2098ecfc077..32756ce494b 100644
--- a/src/test/run-pass/task-comm-chan-cleanup.rs
+++ b/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();
diff --git a/src/test/run-pass/task-comm-chan-cleanup2.rs b/src/test/run-pass/task-comm-chan-cleanup2.rs
index 45d1449972b..39c3eefd774 100644
--- a/src/test/run-pass/task-comm-chan-cleanup2.rs
+++ b/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();
diff --git a/src/test/run-pass/task-comm-chan-cleanup3.rs b/src/test/run-pass/task-comm-chan-cleanup3.rs
index c6aa730d6d2..79c32e5f1fd 100644
--- a/src/test/run-pass/task-comm-chan-cleanup3.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup3.rs
@@ -1,5 +1,5 @@
 use std;
-import std::comm;
+import comm;
 
 fn main() {
     let c = {
diff --git a/src/test/run-pass/task-comm-chan-cleanup4.rs b/src/test/run-pass/task-comm-chan-cleanup4.rs
index 1cf62fa0aea..d7553afb8bb 100644
--- a/src/test/run-pass/task-comm-chan-cleanup4.rs
+++ b/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");
     }
diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs
index 0ee6779847d..785ab6979e2 100644
--- a/src/test/run-pass/task-comm-chan-nil.rs
+++ b/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
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index ad4bb2ee1ce..aa2806bdfbc 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/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();
diff --git a/src/test/run-pass/task-compare.rs b/src/test/run-pass/task-compare.rs
index afd5ebb4d85..be7f658eb1a 100644
--- a/src/test/run-pass/task-compare.rs
+++ b/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() { }
 
diff --git a/src/test/run-pass/task-killjoin.rs b/src/test/run-pass/task-killjoin.rs
index 9df97e7addd..a4ba23ef925 100644
--- a/src/test/run-pass/task-killjoin.rs
+++ b/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
diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs
index d40d397aa40..47afb2aec5f 100644
--- a/src/test/run-pass/task-life-0.rs
+++ b/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) {
diff --git a/src/test/run-pass/task-pin.rs b/src/test/run-pass/task-pin.rs
index 407914dba2d..f989c12fc3c 100644
--- a/src/test/run-pass/task-pin.rs
+++ b/src/test/run-pass/task-pin.rs
@@ -5,6 +5,6 @@
 
 use std;
 
-import std::task;
+import task;
 
 fn main() { task::pin(); task::unpin(); }
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index 4c73e31e1b7..f3fdeea259b 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/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() {
diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs
index e88987bc2cb..bf539066c5f 100644
--- a/src/test/run-pass/test-ignore-cfg.rs
+++ b/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))]
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 0c149769113..d5bbb90b044 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std::task;
+import task;
 
 fn main() {
     let i = 10;
diff --git a/src/test/run-pass/triv-cast-be.rs b/src/test/run-pass/triv-cast-be.rs
index de78341a199..96ab736c525 100644
--- a/src/test/run-pass/triv-cast-be.rs
+++ b/src/test/run-pass/triv-cast-be.rs
@@ -1,6 +1,6 @@
 use std;
 
-import std::ctypes::*;
+import ctypes::*;
 
 fn foo_float() -> m_float { ret 0.0 as m_float; }
 fn bar_float() -> float { be foo_float() as float; }
diff --git a/src/test/run-pass/triv-cast-const.rs b/src/test/run-pass/triv-cast-const.rs
index 59d7d618d23..5aae65ea384 100644
--- a/src/test/run-pass/triv-cast-const.rs
+++ b/src/test/run-pass/triv-cast-const.rs
@@ -1,6 +1,6 @@
 use std;
 
-import std::ctypes::*;
+import ctypes::*;
 
 // This will be more interesting once there is support
 // for consts that refer to other consts, i.e. math_f64::consts::pi as m_float
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index 5713c06e746..0961cb7df3b 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -1,5 +1,5 @@
 use std;
-import std::comm::*;
+import comm::*;
 
 /*
   This is about the simplest program that can successfully send a
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index 5b17568f5dc..ea6c95fc363 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -1,5 +1,5 @@
 // xfail-test
-import std::sys::rustrt::size_of;
+import sys::rustrt::size_of;
 use std;
 
 fn main() {
diff --git a/src/test/run-pass/unify-return-ty.rs b/src/test/run-pass/unify-return-ty.rs
index 81a93b6ab13..c9676b67daa 100644
--- a/src/test/run-pass/unify-return-ty.rs
+++ b/src/test/run-pass/unify-return-ty.rs
@@ -2,7 +2,7 @@
 // unified with the type *T, and so the type variable
 // in that type gets resolved.
 use std;
-import std::unsafe;
+import unsafe;
 
 fn null<T>() -> *T unsafe { unsafe::reinterpret_cast(0) }
 
diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs
index b988e842f93..afcc2f53406 100644
--- a/src/test/run-pass/unique-copy-box.rs
+++ b/src/test/run-pass/unique-copy-box.rs
@@ -1,5 +1,5 @@
 use std;
-import std::sys::refcount;
+import sys::refcount;
 
 fn main() unsafe {
     let i = ~@1;
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index b417ec57dbe..1625e7cc9c1 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -1,7 +1,7 @@
 use std;
-import std::comm;
-import std::task;
-import std::uint;
+import comm;
+import task;
+import uint;
 
 fn child(args: (comm::chan<~uint>, uint)) {
     let (c, i) = args;
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index fbb842aaa6e..58ff64a6cc9 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -1,6 +1,6 @@
 use std;
-import std::comm;
-import std::task;
+import comm;
+import task;
 
 fn main() {
     let p = comm::port();
diff --git a/src/test/run-pass/unwind-box.rs b/src/test/run-pass/unwind-box.rs
index a6f08923433..9cfcd5f5c55 100644
--- a/src/test/run-pass/unwind-box.rs
+++ b/src/test/run-pass/unwind-box.rs
@@ -1,6 +1,6 @@
 // xfail-win32
 use std;
-import std::task;
+import task;
 
 fn f(&&_i: ()) {
     task::unsupervise();
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index b47fcd7ef2d..eaaee443cfc 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -1,7 +1,7 @@
 // xfail-win32
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 resource complainer(c: comm::chan<bool>) {
     comm::send(c, true);
diff --git a/src/test/run-pass/unwind-resource2.rs b/src/test/run-pass/unwind-resource2.rs
index 34a80ed33ea..3d55982a5bb 100644
--- a/src/test/run-pass/unwind-resource2.rs
+++ b/src/test/run-pass/unwind-resource2.rs
@@ -1,7 +1,7 @@
 // xfail-win32
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 resource complainer(c: @int) {
 }
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 071fa594a84..40005d733f5 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -1,6 +1,6 @@
 // xfail-win32
 use std;
-import std::task;
+import task;
 
 fn f(&&_i: ()) {
     task::unsupervise();
diff --git a/src/test/run-pass/use.rs b/src/test/run-pass/use.rs
index 5d5142965ed..78f46ef5f84 100644
--- a/src/test/run-pass/use.rs
+++ b/src/test/run-pass/use.rs
@@ -6,11 +6,11 @@ use bar(name = "std", vers = "0.1");
 
 
 // FIXME: commented out since resolve doesn't know how to handle crates yet.
-// import std::str;
-// import x = std::str;
+// import str;
+// import x = str;
 mod baz {
-    // import std::str;
-    // import x = std::str;
+    // import str;
+    // import x = str;
 
 }
 
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index a17a5021ca8..6587b701518 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -6,10 +6,10 @@ use std (name = "std",
          uuid = _, ver = _);
 
 fn main() {
-  auto s = std::str.alloc(10 as uint);
+  auto s = str.alloc(10 as uint);
   s += "hello ";
   log s;
   s += "there";
   log s;
-  auto z = std::vec.alloc::<int>(10 as uint);
+  auto z = vec.alloc::<int>(10 as uint);
 }
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index e7f7f9a1524..67e3dbcb46c 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -1,6 +1,6 @@
 use std;
-import std::str;
-import std::vec;
+import str;
+import vec;
 
 fn main() {
     // Chars of 1, 2, 3, and 4 bytes
diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index 8e023cf03da..5065fad43d6 100644
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -1,5 +1,5 @@
 use std;
-import std::vec;
+import vec;
 
 fn test_heap_to_heap() {
     // a spills onto the heap
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
index 19701b54b79..bddd8331347 100644
--- a/src/test/run-pass/yield.rs
+++ b/src/test/run-pass/yield.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 use std;
-import std::task;
-import std::task::*;
+import task;
+import task::*;
 
 fn main() {
     let other = task::spawn_joinable((), child);
diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs
index 138c09cffcc..0b207629159 100644
--- a/src/test/run-pass/yield1.rs
+++ b/src/test/run-pass/yield1.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 use std;
-import std::task;
-import std::task::*;
+import task;
+import task::*;
 
 fn main() {
     let other = task::spawn_joinable((), child);
diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs
index 819f6d79cac..9b637c53cb5 100644
--- a/src/test/run-pass/yield2.rs
+++ b/src/test/run-pass/yield2.rs
@@ -3,5 +3,5 @@ use std;
 
 fn main() {
     let i: int = 0;
-    while i < 100 { i = i + 1; log_err i; std::task::yield(); }
+    while i < 100 { i = i + 1; log_err i; task::yield(); }
 }
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index b2ccf093883..d1950be9efa 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -1,10 +1,10 @@
 // In this case, the code should compile and should
 // succeed at runtime
 use std;
-import std::uint;
-import std::u8;
+import uint;
+import u8;
 
-import std::vec::*;
+import vec::*;
 
 fn main() {
     let a = 'a' as u8, j = 'j' as u8, k = 1u, l = 10u;
diff --git a/src/test/stdtest/bitv.rs b/src/test/stdtest/bitv.rs
index 348ee3955dc..ffd3ec232fa 100644
--- a/src/test/stdtest/bitv.rs
+++ b/src/test/stdtest/bitv.rs
@@ -1,6 +1,7 @@
+import core::*;
 
 use std;
-import std::vec;
+import vec;
 import std::bitv;
 
 #[test]
diff --git a/src/test/stdtest/bool.rs b/src/test/stdtest/bool.rs
index 2f91b7aa1e1..528e8e42681 100644
--- a/src/test/stdtest/bool.rs
+++ b/src/test/stdtest/bool.rs
@@ -1,6 +1,8 @@
+import core::*;
+
 use std;
 
-import std::bool;
+import bool;
 
 #[test]
 fn test_bool_from_str() {
diff --git a/src/test/stdtest/box.rs b/src/test/stdtest/box.rs
index c28cb520be8..abe80eec997 100644
--- a/src/test/stdtest/box.rs
+++ b/src/test/stdtest/box.rs
@@ -1,6 +1,7 @@
+import core::*;
 
 use std;
-import std::box;
+import box;
 
 #[test]
 fn test() {
diff --git a/src/test/stdtest/c_vec.rs b/src/test/stdtest/c_vec.rs
index 8ac81274fc7..d196a7baa3b 100644
--- a/src/test/stdtest/c_vec.rs
+++ b/src/test/stdtest/c_vec.rs
@@ -1,7 +1,9 @@
+import core::*;
+
 // -*- rust -*-
 use std;
 import std::c_vec::*;
-import std::ctypes::*;
+import ctypes::*;
 
 #[link_name = ""]
 #[abi = "cdecl"]
diff --git a/src/test/stdtest/char.rs b/src/test/stdtest/char.rs
index ac567d23341..a02abcb5676 100644
--- a/src/test/stdtest/char.rs
+++ b/src/test/stdtest/char.rs
@@ -1,5 +1,7 @@
+import core::*;
+
 use std;
-import std::char;
+import char;
 
 #[test]
 fn test_is_whitespace() {
diff --git a/src/test/stdtest/comm.rs b/src/test/stdtest/comm.rs
index bef5a3c4e5b..fbb0cec73c9 100644
--- a/src/test/stdtest/comm.rs
+++ b/src/test/stdtest/comm.rs
@@ -1,5 +1,7 @@
+import core::*;
+
 use std;
-import std::comm;
+import comm;
 
 #[test]
 fn create_port_and_chan() { let p = comm::port::<int>(); comm::chan(p); }
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index 7a488475b9d..70b2c99f571 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -1,4 +1,4 @@
-
+import core::*;
 
 // -*- rust -*-
 use std;
diff --git a/src/test/stdtest/either.rs b/src/test/stdtest/either.rs
index f79db3088b1..de5849f029f 100644
--- a/src/test/stdtest/either.rs
+++ b/src/test/stdtest/either.rs
@@ -1,6 +1,9 @@
+import core::*;
+
 use std;
-import std::either::*;
-import std::vec::len;
+import vec;
+import core::either::*;
+import vec::len;
 
 #[test]
 fn test_either_left() {
diff --git a/src/test/stdtest/float.rs b/src/test/stdtest/float.rs
index 8720e455586..36f5dc167b1 100644
--- a/src/test/stdtest/float.rs
+++ b/src/test/stdtest/float.rs
@@ -1,5 +1,7 @@
+import core::*;
+
 use std;
-import std::float;
+import float;
 
 #[test]
 fn test_from_str() {
diff --git a/src/test/stdtest/four.rs b/src/test/stdtest/four.rs
index d0af7a393d3..25f1abc4cea 100644
--- a/src/test/stdtest/four.rs
+++ b/src/test/stdtest/four.rs
@@ -1,3 +1,5 @@
+import core::*;
+
 use std;
 
 import std::tri;
diff --git a/src/test/stdtest/fs.rs b/src/test/stdtest/fs.rs
index 66cec07c795..a57cebc332d 100644
--- a/src/test/stdtest/fs.rs
+++ b/src/test/stdtest/fs.rs
@@ -1,6 +1,8 @@
+import core::*;
 
 use std;
 import std::fs;
+import vec;
 
 #[test]
 fn test_connect() {
@@ -18,7 +20,7 @@ fn test_list_dir_no_invalid_memory_access() { fs::list_dir("."); }
 fn list_dir() {
     let dirs = fs::list_dir(".");
     // Just assuming that we've got some contents in the current directory
-    assert (std::vec::len(dirs) > 0u);
+    assert (vec::len(dirs) > 0u);
 
     for dir in dirs { log dir; }
 }
diff --git a/src/test/stdtest/getopts.rs b/src/test/stdtest/getopts.rs
index 781abf48405..3730a17e181 100644
--- a/src/test/stdtest/getopts.rs
+++ b/src/test/stdtest/getopts.rs
@@ -1,3 +1,4 @@
+import core::*;
 
 use std;
 import opt = std::getopts;
diff --git a/src/test/stdtest/int.rs b/src/test/stdtest/int.rs
index 43bdf39ee00..c8ec806189f 100644
--- a/src/test/stdtest/int.rs
+++ b/src/test/stdtest/int.rs
@@ -1,8 +1,10 @@
+import core::*;
 
 use std;
-import std::int;
-import std::str::eq;
-import std::str::bytes;
+import str;
+import int;
+import str::eq;
+import str::bytes;
 
 #[test]
 fn test_from_str() {
diff --git a/src/test/stdtest/io.rs b/src/test/stdtest/io.rs
index dcb6559dc7a..1c9774b7fe6 100644
--- a/src/test/stdtest/io.rs
+++ b/src/test/stdtest/io.rs
@@ -1,8 +1,10 @@
+import core::*;
+
 // -*- rust -*-
 use std;
 import std::io;
-import std::str;
-import std::result;
+import str;
+import result;
 
 #[test]
 fn test_simple() {
diff --git a/src/test/stdtest/json.rs b/src/test/stdtest/json.rs
index a19ddec5e7d..db65b223ff7 100644
--- a/src/test/stdtest/json.rs
+++ b/src/test/stdtest/json.rs
@@ -1,6 +1,9 @@
+import core::*;
+
 use std;
+import option;
 import std::json::*;
-import std::option::{none, some};
+import option::{none, some};
 
 #[test]
 fn test_from_str_num() {
diff --git a/src/test/stdtest/list.rs b/src/test/stdtest/list.rs
index 453ed7fc9ba..da1643e9274 100644
--- a/src/test/stdtest/list.rs
+++ b/src/test/stdtest/list.rs
@@ -1,10 +1,11 @@
+import core::*;
 
 use std;
 import std::list;
 import std::list::head;
 import std::list::tail;
 import std::list::from_vec;
-import std::option;
+import option;
 
 #[test]
 fn test_from_vec() {
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index 40149b1407f..b7e62a6b0d2 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -1,11 +1,11 @@
-
+import core::*;
 
 // -*- rust -*-
 use std;
 import std::map;
-import std::str;
-import std::uint;
-import std::option;
+import str;
+import uint;
+import option;
 
 
 #[test]
@@ -257,7 +257,7 @@ fn test_contains_key() {
 fn test_find() {
     let key = "k";
     let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
-    assert (std::option::is_none(map.find(key)));
+    assert (option::is_none(map.find(key)));
     map.insert(key, "val");
-    assert (std::option::get(map.find(key)) == "val");
+    assert (option::get(map.find(key)) == "val");
 }
diff --git a/src/test/stdtest/math.rs b/src/test/stdtest/math.rs
index 0b319888dcd..bff63340cf5 100644
--- a/src/test/stdtest/math.rs
+++ b/src/test/stdtest/math.rs
@@ -1,8 +1,10 @@
+import core::*;
+
 use std;
 
 import std::math::*;
-import std::float;
-import c_int = std::ctypes::c_int;
+import float;
+import c_int = ctypes::c_int;
 
 #[test]
 fn test_max_min() {
diff --git a/src/test/stdtest/net.rs b/src/test/stdtest/net.rs
index 9da7a12a060..c0872db3fc7 100644
--- a/src/test/stdtest/net.rs
+++ b/src/test/stdtest/net.rs
@@ -1,3 +1,5 @@
+import core::*;
+
 use std;
 import std::net;
 
diff --git a/src/test/stdtest/option.rs b/src/test/stdtest/option.rs
index 0cca3a65a4f..a04751da101 100644
--- a/src/test/stdtest/option.rs
+++ b/src/test/stdtest/option.rs
@@ -1,5 +1,6 @@
+import core::*;
 
 use std;
 
 #[test]
-fn test() { let _x = std::option::some::<int>(10); }
+fn test() { let _x = option::some::<int>(10); }
diff --git a/src/test/stdtest/os.rs b/src/test/stdtest/os.rs
index 8f7b5f5dc23..1236a790925 100644
--- a/src/test/stdtest/os.rs
+++ b/src/test/stdtest/os.rs
@@ -1,6 +1,8 @@
+import core::*;
+
 import std::generic_os::setenv;
 import std::generic_os::getenv;
-import std::option;
+import option;
 
 #[test]
 #[ignore(reason = "fails periodically on mac")]
@@ -38,7 +40,7 @@ fn get_exe_path() {
 
     // Hard to test this function
     if std::os::target_os() != "win32" {
-        assert std::str::starts_with(path, std::fs::path_sep());
+        assert str::starts_with(path, std::fs::path_sep());
     } else {
         assert path[1] == ':' as u8;
     }
diff --git a/src/test/stdtest/path.rs b/src/test/stdtest/path.rs
index 911bc6b0dd9..911b1fa6404 100644
--- a/src/test/stdtest/path.rs
+++ b/src/test/stdtest/path.rs
@@ -1,3 +1,4 @@
+import core::*;
 
 // Testing a few of the path manipuation functions
 
diff --git a/src/test/stdtest/ptr.rs b/src/test/stdtest/ptr.rs
index 6a353bcdeea..a2242b1a06d 100644
--- a/src/test/stdtest/ptr.rs
+++ b/src/test/stdtest/ptr.rs
@@ -1,6 +1,8 @@
+import core::*;
+
 use std;
-import std::ptr;
-import std::unsafe;
+import ptr;
+import unsafe;
 
 type pair = {mutable fst: int, mutable snd: int};
 
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index cb0433ca02b..123fb39d25e 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -1,12 +1,13 @@
+import core::*;
 
 use std;
 
 import std::sort;
-import std::vec;
-import std::int;
+import vec;
+import int;
 
 fn check_sort(v1: [mutable int], v2: [mutable int]) {
-    let len = std::vec::len::<int>(v1);
+    let len = vec::len::<int>(v1);
     fn ltequal(&&a: int, &&b: int) -> bool { ret a <= b; }
     let f = ltequal;
     std::sort::quick_sort::<int>(f, v1);
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 1a4f080369b..0b178a00591 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -1,8 +1,9 @@
+import core::*;
 
 use std;
 
 fn check_sort(v1: [mutable int], v2: [mutable int]) {
-    let len = std::vec::len::<int>(v1);
+    let len = vec::len::<int>(v1);
     fn lt(&&a: int, &&b: int) -> bool { ret a < b; }
     fn equal(&&a: int, &&b: int) -> bool { ret a == b; }
     let f1 = lt;
diff --git a/src/test/stdtest/rand.rs b/src/test/stdtest/rand.rs
index b0d71d0e431..2ee04719776 100644
--- a/src/test/stdtest/rand.rs
+++ b/src/test/stdtest/rand.rs
@@ -1,9 +1,9 @@
-
+import core::*;
 
 // -*- rust -*-
 use std;
 import std::rand;
-import std::str;
+import str;
 
 #[test]
 fn test() {
diff --git a/src/test/stdtest/result.rs b/src/test/stdtest/result.rs
index 9a7b390a523..ed041349176 100644
--- a/src/test/stdtest/result.rs
+++ b/src/test/stdtest/result.rs
@@ -1,4 +1,6 @@
-import std::result;
+import core::*;
+
+import result;
 
 fn op1() -> result::t<int, str> { result::ok(666) }
 
diff --git a/src/test/stdtest/rope.rs b/src/test/stdtest/rope.rs
index 1ed920f2fb9..d59676522b7 100644
--- a/src/test/stdtest/rope.rs
+++ b/src/test/stdtest/rope.rs
@@ -1,8 +1,10 @@
-import std::str;
+import core::*;
+
+import str;
 import std::rope::*;
-import std::option;
-import std::uint;
-import std::vec;
+import option;
+import uint;
+import vec;
 
 //Utility function, used for sanity check
 fn rope_to_string(r: rope) -> str {
diff --git a/src/test/stdtest/run.rs b/src/test/stdtest/run.rs
index 7b8248833b1..9f6bc4c424d 100644
--- a/src/test/stdtest/run.rs
+++ b/src/test/stdtest/run.rs
@@ -1,10 +1,12 @@
+import core::*;
+
 use std;
 import std::run;
 import std::os;
 import std::io;
-import std::option;
-import std::str;
-import std::ctypes::fd_t;
+import option;
+import str;
+import ctypes::fd_t;
 
 // Regression test for memory leaks
 #[ignore(cfg(target_os = "win32"))] // FIXME
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index 8731692169b..e1b8a4a8d59 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -1,11 +1,11 @@
-
+import core::*;
 
 // -*- rust -*-
 
 use std;
 import std::sha1;
-import std::vec;
-import std::str;
+import vec;
+import str;
 
 #[test]
 fn test() {
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index 9e362f0c988..717a1d829a6 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -1,8 +1,9 @@
+import core::*;
 
 use std;
 
 fn check_sort(v1: [int], v2: [int]) {
-    let len = std::vec::len::<int>(v1);
+    let len = vec::len::<int>(v1);
     fn lteq(&&a: int, &&b: int) -> bool { ret a <= b; }
     let f = lteq;
     let v3 = std::sort::merge_sort::<int>(f, v1);
diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index cc23eb5bb1b..d540f32ea51 100644
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -1,5 +1,7 @@
-import std::str;
-import std::vec;
+import core::*;
+
+import str;
+import vec;
 
 #[test]
 fn test_eq() {
@@ -333,6 +335,6 @@ fn iter_chars() {
 fn escape() {
     assert(str::escape("abcdef") == "abcdef");
     assert(str::escape("abc\\def") == "abc\\\\def");
-    assert(str::escape("abc\ndef") == "abc\\x0adef");
+    assert(str::escape("abc\ndef") == "abc\\ndef");
     assert(str::escape("abc\"def") == "abc\\\"def");
 }
diff --git a/src/test/stdtest/sys.rs b/src/test/stdtest/sys.rs
index 8098d94a0a9..35e14b5df1d 100644
--- a/src/test/stdtest/sys.rs
+++ b/src/test/stdtest/sys.rs
@@ -1,4 +1,6 @@
-import std::sys;
+import core::*;
+
+import sys;
 
 #[test]
 fn last_os_error() {
diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index a444fbbcc08..78e85c881b0 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -1,6 +1,8 @@
+import core::*;
+
 use std;
-import std::task;
-import std::comm;
+import task;
+import comm;
 
 #[test]
 fn test_sleep() { task::sleep(1000000u); }
diff --git a/src/test/stdtest/tempfile.rs b/src/test/stdtest/tempfile.rs
index 2f78d3e8a92..7db30fa67a1 100644
--- a/src/test/stdtest/tempfile.rs
+++ b/src/test/stdtest/tempfile.rs
@@ -1,7 +1,10 @@
+import core::*;
+
 use std;
+import option;
 import std::fs;
-import std::option::some;
-import std::str;
+import option::some;
+import str;
 import std::tempfile;
 
 #[test]
diff --git a/src/test/stdtest/test.rs b/src/test/stdtest/test.rs
index d6001ebbe54..0de4c1820a8 100644
--- a/src/test/stdtest/test.rs
+++ b/src/test/stdtest/test.rs
@@ -1,8 +1,10 @@
+import core::*;
+
 import std::test;
-import std::str;
-import std::option;
-import std::either;
-import std::vec;
+import str;
+import option;
+import either;
+import vec;
 
 #[test]
 fn do_not_run_ignored_tests() {
diff --git a/src/test/stdtest/treemap.rs b/src/test/stdtest/treemap.rs
index 2fba1ebb196..90aba286e6e 100644
--- a/src/test/stdtest/treemap.rs
+++ b/src/test/stdtest/treemap.rs
@@ -1,8 +1,11 @@
+import core::*;
+
 use std;
+import option;
 import std::treemap::*;
-import std::option::some;
-import std::option::none;
-import std::str;
+import option::some;
+import option::none;
+import str;
 
 #[test]
 fn init_treemap() { let _m = init::<int, int>(); }
diff --git a/src/test/stdtest/tri.rs b/src/test/stdtest/tri.rs
index 4ea87c1270e..c560bc0b681 100644
--- a/src/test/stdtest/tri.rs
+++ b/src/test/stdtest/tri.rs
@@ -1,3 +1,5 @@
+import core::*;
+
 use std;
 
 import std::tri;
diff --git a/src/test/stdtest/uint.rs b/src/test/stdtest/uint.rs
index adb1cde32a9..43187994829 100644
--- a/src/test/stdtest/uint.rs
+++ b/src/test/stdtest/uint.rs
@@ -1,9 +1,10 @@
-
+import core::*;
 
 // -*- rust -*-
 use std;
-import std::uint;
-import std::str::bytes;
+import str;
+import uint;
+import str::bytes;
 
 #[test]
 fn test_from_str() {
diff --git a/src/test/stdtest/unsafe.rs b/src/test/stdtest/unsafe.rs
index 673e14c01f4..b8197cf4c23 100644
--- a/src/test/stdtest/unsafe.rs
+++ b/src/test/stdtest/unsafe.rs
@@ -1,4 +1,6 @@
-import std::unsafe;
+import core::*;
+
+import unsafe;
 
 #[test]
 fn reinterpret_cast() unsafe {
diff --git a/src/test/stdtest/uv.rs b/src/test/stdtest/uv.rs
index 1dda6957a5d..5529ee7a2bb 100644
--- a/src/test/stdtest/uv.rs
+++ b/src/test/stdtest/uv.rs
@@ -1,8 +1,11 @@
+
 #[cfg(target_os = "linux")];
 #[cfg(target_os = "macos")];
 
+import core::*;
+
 import std::uv;
-import std::ptr;
+import ptr;
 
 #[test]
 fn sanity_check() {
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index 3d04e6d3a2e..19ff2d59cc5 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -1,11 +1,12 @@
+import core::*;
+
+import vec;
+import vec::*;
+import option;
+import option::none;
+import option::some;
+import task;
 
-use std;
-import std::vec;
-import std::vec::*;
-import std::option;
-import std::option::none;
-import std::option::some;
-import std::task;
 
 fn square(n: uint) -> uint { ret n * n; }
author	Graydon Hoare <graydon@mozilla.com>	2011-12-13 16:25:51 -0800
committer	Graydon Hoare <graydon@mozilla.com>	2011-12-13 16:34:50 -0800
commit	fa9ad984fb2f013baebdbe01a42baa3b9101dd84 (patch)
tree	49115690e45ca322337b93f25308cd618f85b013 /src/test
parent	32087f5c2a35bf8050067c22a57fd60269633a60 (diff)
download	rust-fa9ad984fb2f013baebdbe01a42baa3b9101dd84.tar.gz rust-fa9ad984fb2f013baebdbe01a42baa3b9101dd84.zip