Downcase std modules again, move to :: for module dereferencing

This should be a snapshot transition.

57 files changed, 491 insertions, 491 deletions

diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index 8f45e6ff..a785f91d 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/src/test/run-pass/alt-join.rs
@@ -1,10 +1,10 @@
 use std;
-import std.Option;
-import std.Option.t;
-import std.Option.none;
-import std.Option.some;
+import std::option;
+import std::option::t;
+import std::option::none;
+import std::option::some;
 
-fn foo[T](&Option.t[T] y) {
+fn foo[T](&option::t[T] y) {
   let int x;
   
   let vec[int] res = vec();
diff --git a/src/test/run-pass/alt-path.rs b/src/test/run-pass/alt-path.rs
index ad55713b..205500e1 100644
--- a/src/test/run-pass/alt-path.rs
+++ b/src/test/run-pass/alt-path.rs
@@ -4,9 +4,9 @@ mod m1 {
     foo2;
   }
 }
-fn bar(m1.foo x) {
+fn bar(m1::foo x) {
   alt(x) {
-    case (m1.foo1) {
+      case (m1::foo1) {
     }
   }
 }
diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index 76e7c3aa..a59248eb 100644
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -1,9 +1,9 @@
 // -*- rust -*-
 
 use std;
-import std.Str;
+import std::_str;
 
-// FIXME: import std.Dbg.const_refcount. Currently
+// FIXME: import std::dbg.const_refcount. Currently
 // cross-crate const references don't work.
 const uint const_refcount = 0x7bad_face_u;
 
@@ -20,13 +20,13 @@ fn foo(str s) {
     case (_) { log "?"; fail; }
   }
 
-  log Str.refcount(s);
-  assert (Str.refcount(s) == const_refcount);
+  log _str::refcount(s);
+  assert (_str::refcount(s) == const_refcount);
 }
 
 fn main() {
   let str s = "hi";     // ref up
   foo(s);               // ref up then down
-  log Str.refcount(s);
-  assert (Str.refcount(s) == const_refcount);
+  log _str::refcount(s);
+  assert (_str::refcount(s) == const_refcount);
 }
diff --git a/src/test/run-pass/export-abstract-tag.rs b/src/test/run-pass/export-abstract-tag.rs
index b192b698..7e488631 100644
--- a/src/test/run-pass/export-abstract-tag.rs
+++ b/src/test/run-pass/export-abstract-tag.rs
@@ -15,5 +15,5 @@ mod foo {
 }
 
 fn main() {
-  let foo.t v = foo.f();
+  let foo::t v = foo::f();
 }
diff --git a/src/test/run-pass/export-non-interference2.rs b/src/test/run-pass/export-non-interference2.rs
index e5b324e4..533df528 100644
--- a/src/test/run-pass/export-non-interference2.rs
+++ b/src/test/run-pass/export-non-interference2.rs
@@ -14,5 +14,5 @@ mod foo {
 }
 
 fn main() {
-  foo.bar.y();
+  foo::bar::y();
 }
diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs
index c52b13f7..7b936b63 100644
--- a/src/test/run-pass/export-non-interference3.rs
+++ b/src/test/run-pass/export-non-interference3.rs
@@ -2,7 +2,7 @@ mod foo {
   export x;
 
   fn x() {
-    bar.x();
+    bar::x();
   }
 }
 
@@ -15,5 +15,5 @@ mod bar {
 }
 
 fn main() {
-  foo.x();
+  foo::x();
 }
diff --git a/src/test/run-pass/export-tag-variant.rs b/src/test/run-pass/export-tag-variant.rs
index e99bc041..309261a5 100644
--- a/src/test/run-pass/export-tag-variant.rs
+++ b/src/test/run-pass/export-tag-variant.rs
@@ -8,5 +8,5 @@ mod foo {
 }
 
 fn main() {
-  auto v = foo.t1;
+  auto v = foo::t1;
 }
diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs
index 94ef5241..dcb88af2 100644
--- a/src/test/run-pass/export-unexported-dep.rs
+++ b/src/test/run-pass/export-unexported-dep.rs
@@ -20,5 +20,5 @@ mod foo {
 }
 
 fn main() {
-  foo.g(foo.f());
+  foo::g(foo::f());
 }
\ No newline at end of file
diff --git a/src/test/run-pass/generic-fn-twice.rs b/src/test/run-pass/generic-fn-twice.rs
index 0c6257f8..49dc3ed7 100644
--- a/src/test/run-pass/generic-fn-twice.rs
+++ b/src/test/run-pass/generic-fn-twice.rs
@@ -5,6 +5,6 @@ mod foomod {
 }
 
 fn main() {
-  foomod.foo[int]();
-  foomod.foo[int]();
+  foomod::foo[int]();
+  foomod::foo[int]();
 }
diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs
index 76de0d18..2bccd392 100644
--- a/src/test/run-pass/import.rs
+++ b/src/test/run-pass/import.rs
@@ -5,8 +5,8 @@ mod foo {
 }
 
 mod bar {
-  import foo.x;
-  import z = foo.x;
+  import foo::x;
+  import z = foo::x;
   fn main() {
     x(10);
     z(10);
diff --git a/src/test/run-pass/import2.rs b/src/test/run-pass/import2.rs
index 31b49aea..2531b857 100644
--- a/src/test/run-pass/import2.rs
+++ b/src/test/run-pass/import2.rs
@@ -1,4 +1,4 @@
-import zed.bar;
+import zed::bar;
 mod zed {
   fn bar() {
     log "bar";
diff --git a/src/test/run-pass/import3.rs b/src/test/run-pass/import3.rs
index 559c6ee9..282c4d23 100644
--- a/src/test/run-pass/import3.rs
+++ b/src/test/run-pass/import3.rs
@@ -1,5 +1,5 @@
-import zed.bar;
-import baz.zed;
+import zed::bar;
+import baz::zed;
 mod baz {
   mod zed {
     fn bar() {
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 5b0cb9f3..2c4170a3 100644
--- a/src/test/run-pass/import4.rs
+++ b/src/test/run-pass/import4.rs
@@ -1,4 +1,4 @@
-import zed.bar;
+import zed::bar;
 mod zed {
   fn bar() {
     log "bar";
diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs
index 5e07e708..077cc14c 100644
--- a/src/test/run-pass/import5.rs
+++ b/src/test/run-pass/import5.rs
@@ -1,6 +1,6 @@
-import foo.bar;
+import foo::bar;
 mod foo {
-  import zed.bar;
+  import zed::bar;
   mod zed {
     fn bar() {
       log "foo";
diff --git a/src/test/run-pass/import6.rs b/src/test/run-pass/import6.rs
index 5e3a9d74..c8268d99 100644
--- a/src/test/run-pass/import6.rs
+++ b/src/test/run-pass/import6.rs
@@ -1,5 +1,5 @@
-import bar.baz;
-import foo.zed;
+import bar::baz;
+import foo::zed;
 mod foo {
   mod zed {
     fn baz() {
@@ -8,7 +8,7 @@ mod foo {
   }
 }
 mod bar {
-  import zed.baz;
+  import zed::baz;
 }
 fn main(vec[str] args) {
   baz();
diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs
index 29915fb1..6b11762e 100644
--- a/src/test/run-pass/import7.rs
+++ b/src/test/run-pass/import7.rs
@@ -1,5 +1,5 @@
-import bar.baz;
-import foo.zed;
+import bar::baz;
+import foo::zed;
 mod foo {
   mod zed {
     fn baz() {
@@ -8,7 +8,7 @@ mod foo {
   }
 }
 mod bar {
-  import zed.baz;
+  import zed::baz;
   mod foo {
     mod zed {
     }
diff --git a/src/test/run-pass/import8.rs b/src/test/run-pass/import8.rs
index 5031e984..753d6da0 100644
--- a/src/test/run-pass/import8.rs
+++ b/src/test/run-pass/import8.rs
@@ -1,5 +1,5 @@
-import foo.x;
-import z = foo.x;
+import foo::x;
+import z = foo::x;
 
 mod foo {
   fn x(int y) {
diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs
index f5066b6e..03f32bc4 100644
--- a/src/test/run-pass/inner-module.rs
+++ b/src/test/run-pass/inner-module.rs
@@ -7,11 +7,11 @@ mod inner {
     }
   }
   fn hello() {
-    inner2.hello();
+    inner2::hello();
   }
 }
 
 fn main() {
-  inner.hello();
-  inner.inner2.hello();
+  inner::hello();
+  inner::inner2::hello();
 }
diff --git a/src/test/run-pass/lib-bitv.rs b/src/test/run-pass/lib-bitv.rs
index b047f47a..506d5b2a 100644
--- a/src/test/run-pass/lib-bitv.rs
+++ b/src/test/run-pass/lib-bitv.rs
@@ -1,132 +1,132 @@
 use std;
-import std.Vec;
-import std.BitV;
+import std::_vec;
+import std::bitv;
 
 fn test_0_elements() {
   auto act;
   auto exp;
 
-  act = BitV.create(0u, false);
-  exp = Vec.init_elt[uint](0u, 0u);
+  act = bitv::create(0u, false);
+  exp = _vec::init_elt[uint](0u, 0u);
   // FIXME: why can't I write vec[uint]()?
-  assert (BitV.eq_vec(act, exp));
+  assert (bitv::eq_vec(act, exp));
 }
 
 fn test_1_element() {
   auto act;
 
-  act = BitV.create(1u, false);
-  assert (BitV.eq_vec(act, vec(0u)));
+  act = bitv::create(1u, false);
+  assert (bitv::eq_vec(act, vec(0u)));
 
-  act = BitV.create(1u, true);
-  assert (BitV.eq_vec(act, vec(1u)));
+  act = bitv::create(1u, true);
+  assert (bitv::eq_vec(act, vec(1u)));
 }
 
 fn test_10_elements() {
   auto act;
 
   // all 0
-  act = BitV.create(10u, false);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+  act = bitv::create(10u, false);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // all 1
-  act = BitV.create(10u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+  act = bitv::create(10u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(10u, false);
-  BitV.set(act, 0u, true);
-  BitV.set(act, 1u, true);
-  BitV.set(act, 2u, true);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 4u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
+  act = bitv::create(10u, false);
+  bitv::set(act, 0u, true);
+  bitv::set(act, 1u, true);
+  bitv::set(act, 2u, true);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 4u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
 
   // mixed
-  act = BitV.create(10u, false);
-  BitV.set(act, 5u, true);
-  BitV.set(act, 6u, true);
-  BitV.set(act, 7u, true);
-  BitV.set(act, 8u, true);
-  BitV.set(act, 9u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
+  act = bitv::create(10u, false);
+  bitv::set(act, 5u, true);
+  bitv::set(act, 6u, true);
+  bitv::set(act, 7u, true);
+  bitv::set(act, 8u, true);
+  bitv::set(act, 9u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(10u, false);
-  BitV.set(act, 0u, true);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 6u, true);
-  BitV.set(act, 9u, true);
-  assert (BitV.eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
+  act = bitv::create(10u, false);
+  bitv::set(act, 0u, true);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 6u, true);
+  bitv::set(act, 9u, true);
+  assert (bitv::eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
 }
 
 fn test_31_elements() {
   auto act;
 
   // all 0
-  act = BitV.create(31u, false);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(31u, false);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // all 1
-  act = BitV.create(31u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(31u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(31u, false);
-  BitV.set(act, 0u, true);
-  BitV.set(act, 1u, true);
-  BitV.set(act, 2u, true);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 4u, true);
-  BitV.set(act, 5u, true);
-  BitV.set(act, 6u, true);
-  BitV.set(act, 7u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(31u, false);
+  bitv::set(act, 0u, true);
+  bitv::set(act, 1u, true);
+  bitv::set(act, 2u, true);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 4u, true);
+  bitv::set(act, 5u, true);
+  bitv::set(act, 6u, true);
+  bitv::set(act, 7u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // mixed
-  act = BitV.create(31u, false);
-  BitV.set(act, 16u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 18u, true);
-  BitV.set(act, 19u, true);
-  BitV.set(act, 20u, true);
-  BitV.set(act, 21u, true);
-  BitV.set(act, 22u, true);
-  BitV.set(act, 23u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(31u, false);
+  bitv::set(act, 16u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 18u, true);
+  bitv::set(act, 19u, true);
+  bitv::set(act, 20u, true);
+  bitv::set(act, 21u, true);
+  bitv::set(act, 22u, true);
+  bitv::set(act, 23u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // mixed
-  act = BitV.create(31u, false);
-  BitV.set(act, 24u, true);
-  BitV.set(act, 25u, true);
-  BitV.set(act, 26u, true);
-  BitV.set(act, 27u, true);
-  BitV.set(act, 28u, true);
-  BitV.set(act, 29u, true);
-  BitV.set(act, 30u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(31u, false);
+  bitv::set(act, 24u, true);
+  bitv::set(act, 25u, true);
+  bitv::set(act, 26u, true);
+  bitv::set(act, 27u, true);
+  bitv::set(act, 28u, true);
+  bitv::set(act, 29u, true);
+  bitv::set(act, 30u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(31u, false);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 30u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  act = bitv::create(31u, false);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 30u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 1u)));
@@ -136,71 +136,71 @@ fn test_32_elements() {
   auto act;
 
   // all 0
-  act = BitV.create(32u, false);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(32u, false);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // all 1
-  act = BitV.create(32u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(32u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(32u, false);
-  BitV.set(act, 0u, true);
-  BitV.set(act, 1u, true);
-  BitV.set(act, 2u, true);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 4u, true);
-  BitV.set(act, 5u, true);
-  BitV.set(act, 6u, true);
-  BitV.set(act, 7u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(32u, false);
+  bitv::set(act, 0u, true);
+  bitv::set(act, 1u, true);
+  bitv::set(act, 2u, true);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 4u, true);
+  bitv::set(act, 5u, true);
+  bitv::set(act, 6u, true);
+  bitv::set(act, 7u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // mixed
-  act = BitV.create(32u, false);
-  BitV.set(act, 16u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 18u, true);
-  BitV.set(act, 19u, true);
-  BitV.set(act, 20u, true);
-  BitV.set(act, 21u, true);
-  BitV.set(act, 22u, true);
-  BitV.set(act, 23u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(32u, false);
+  bitv::set(act, 16u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 18u, true);
+  bitv::set(act, 19u, true);
+  bitv::set(act, 20u, true);
+  bitv::set(act, 21u, true);
+  bitv::set(act, 22u, true);
+  bitv::set(act, 23u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
 
   // mixed
-  act = BitV.create(32u, false);
-  BitV.set(act, 24u, true);
-  BitV.set(act, 25u, true);
-  BitV.set(act, 26u, true);
-  BitV.set(act, 27u, true);
-  BitV.set(act, 28u, true);
-  BitV.set(act, 29u, true);
-  BitV.set(act, 30u, true);
-  BitV.set(act, 31u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(32u, false);
+  bitv::set(act, 24u, true);
+  bitv::set(act, 25u, true);
+  bitv::set(act, 26u, true);
+  bitv::set(act, 27u, true);
+  bitv::set(act, 28u, true);
+  bitv::set(act, 29u, true);
+  bitv::set(act, 30u, true);
+  bitv::set(act, 31u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
 
   // mixed
-  act = BitV.create(32u, false);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 30u, true);
-  BitV.set(act, 31u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  act = bitv::create(32u, false);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 30u, true);
+  bitv::set(act, 31u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u)));
@@ -210,77 +210,77 @@ fn test_33_elements() {
   auto act;
 
   // all 0
-  act = BitV.create(33u, false);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(33u, false);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u)));
 
   // all 1
-  act = BitV.create(33u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(33u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u)));
 
   // mixed
-  act = BitV.create(33u, false);
-  BitV.set(act, 0u, true);
-  BitV.set(act, 1u, true);
-  BitV.set(act, 2u, true);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 4u, true);
-  BitV.set(act, 5u, true);
-  BitV.set(act, 6u, true);
-  BitV.set(act, 7u, true);
-  assert (BitV.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  act = bitv::create(33u, false);
+  bitv::set(act, 0u, true);
+  bitv::set(act, 1u, true);
+  bitv::set(act, 2u, true);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 4u, true);
+  bitv::set(act, 5u, true);
+  bitv::set(act, 6u, true);
+  bitv::set(act, 7u, true);
+  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u)));
 
   // mixed
-  act = BitV.create(33u, false);
-  BitV.set(act, 16u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 18u, true);
-  BitV.set(act, 19u, true);
-  BitV.set(act, 20u, true);
-  BitV.set(act, 21u, true);
-  BitV.set(act, 22u, true);
-  BitV.set(act, 23u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(33u, false);
+  bitv::set(act, 16u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 18u, true);
+  bitv::set(act, 19u, true);
+  bitv::set(act, 20u, true);
+  bitv::set(act, 21u, true);
+  bitv::set(act, 22u, true);
+  bitv::set(act, 23u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u)));
 
   // mixed
-  act = BitV.create(33u, false);
-  BitV.set(act, 24u, true);
-  BitV.set(act, 25u, true);
-  BitV.set(act, 26u, true);
-  BitV.set(act, 27u, true);
-  BitV.set(act, 28u, true);
-  BitV.set(act, 29u, true);
-  BitV.set(act, 30u, true);
-  BitV.set(act, 31u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  act = bitv::create(33u, false);
+  bitv::set(act, 24u, true);
+  bitv::set(act, 25u, true);
+  bitv::set(act, 26u, true);
+  bitv::set(act, 27u, true);
+  bitv::set(act, 28u, true);
+  bitv::set(act, 29u, true);
+  bitv::set(act, 30u, true);
+  bitv::set(act, 31u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u)));
 
   // mixed
-  act = BitV.create(33u, false);
-  BitV.set(act, 3u, true);
-  BitV.set(act, 17u, true);
-  BitV.set(act, 30u, true);
-  BitV.set(act, 31u, true);
-  BitV.set(act, 32u, true);
-  assert (BitV.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  act = bitv::create(33u, false);
+  bitv::set(act, 3u, true);
+  bitv::set(act, 17u, true);
+  bitv::set(act, 30u, true);
+  bitv::set(act, 31u, true);
+  bitv::set(act, 32u, true);
+  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
diff --git a/src/test/run-pass/lib-box.rs b/src/test/run-pass/lib-box.rs
index 62807251..e0e10f5a 100644
--- a/src/test/run-pass/lib-box.rs
+++ b/src/test/run-pass/lib-box.rs
@@ -1,12 +1,12 @@
 use std;
-import std.Box;
+import std::box;
 
 fn main() {
     auto x = @3;
     auto y = @3;
-    assert (Box.ptr_eq[int](x, x));
-    assert (Box.ptr_eq[int](y, y));
-    assert (!Box.ptr_eq[int](x, y));
-    assert (!Box.ptr_eq[int](y, x));
+    assert (box::ptr_eq[int](x, x));
+    assert (box::ptr_eq[int](y, y));
+    assert (!box::ptr_eq[int](x, y));
+    assert (!box::ptr_eq[int](y, x));
 }
 
diff --git a/src/test/run-pass/lib-deque.rs b/src/test/run-pass/lib-deque.rs
index 9de238dc..186697fb 100644
--- a/src/test/run-pass/lib-deque.rs
+++ b/src/test/run-pass/lib-deque.rs
@@ -1,10 +1,10 @@
 // -*- rust -*-
 
 use std;
-import std.Deque;
+import std::deque;
 
 fn test_simple() {
-  let Deque.t[int] d = Deque.create[int]();
+  let deque::t[int] d = deque::create[int]();
   assert (d.size() == 0u);
   d.add_front(17);
   d.add_front(42);
@@ -57,7 +57,7 @@ fn test_simple() {
 }
 
 fn test_boxes(@int a, @int b, @int c, @int d) {
-  let Deque.t[@int] deq = Deque.create[@int]();
+  let deque::t[@int] deq = deque::create[@int]();
   assert (deq.size() == 0u);
   deq.add_front(a);
   deq.add_front(b);
@@ -93,7 +93,7 @@ fn test_boxes(@int a, @int b, @int c, @int d) {
 type eqfn[T] = fn(&T a, &T b) -> bool;
 
 fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) {
-  let Deque.t[T] deq = Deque.create[T]();
+  let deque::t[T] deq = deque::create[T]();
   assert (deq.size() == 0u);
   deq.add_front(a);
   deq.add_front(b);
diff --git a/src/test/run-pass/lib-int.rs b/src/test/run-pass/lib-int.rs
index a5a9a2a1..20d70ccf 100644
--- a/src/test/run-pass/lib-int.rs
+++ b/src/test/run-pass/lib-int.rs
@@ -1,25 +1,25 @@
 use std;
 
-import std.Int;
-import std.Str.eq;
+import std::_int;
+import std::_str::eq;
 
 fn test_to_str() {
-  assert (eq(Int.to_str(0, 10u), "0"));
-  assert (eq(Int.to_str(1, 10u), "1"));
-  assert (eq(Int.to_str(-1, 10u), "-1"));
-  assert (eq(Int.to_str(255, 16u), "ff"));
-  assert (eq(Int.to_str(100, 10u), "100"));
+  assert (eq(_int::to_str(0, 10u), "0"));
+  assert (eq(_int::to_str(1, 10u), "1"));
+  assert (eq(_int::to_str(-1, 10u), "-1"));
+  assert (eq(_int::to_str(255, 16u), "ff"));
+  assert (eq(_int::to_str(100, 10u), "100"));
 }
 
 fn test_pow() {
-  assert (Int.pow(0, 0u) == 1);
-  assert (Int.pow(0, 1u) == 0);
-  assert (Int.pow(0, 2u) == 0);
-  assert (Int.pow(-1, 0u) == -1);
-  assert (Int.pow(1, 0u) == 1);
-  assert (Int.pow(-3, 2u) == 9);
-  assert (Int.pow(-3, 3u) == -27);
-  assert (Int.pow(4, 9u) == 262144);
+  assert (_int::pow(0, 0u) == 1);
+  assert (_int::pow(0, 1u) == 0);
+  assert (_int::pow(0, 2u) == 0);
+  assert (_int::pow(-1, 0u) == -1);
+  assert (_int::pow(1, 0u) == 1);
+  assert (_int::pow(-3, 2u) == 9);
+  assert (_int::pow(-3, 3u) == -27);
+  assert (_int::pow(4, 9u) == 262144);
 }
 
 fn main() {
diff --git a/src/test/run-pass/lib-io.rs b/src/test/run-pass/lib-io.rs
index e124cde3..53c13912 100644
--- a/src/test/run-pass/lib-io.rs
+++ b/src/test/run-pass/lib-io.rs
@@ -5,8 +5,8 @@
 // -*- rust -*-
 
 use std;
-import std.IO;
-import std.Str;
+import std::io;
+import std::_str;
 
 fn test_simple(str tmpfilebase) {
   let str tmpfile = tmpfilebase + ".tmp";
@@ -15,14 +15,14 @@ fn test_simple(str tmpfilebase) {
   log frood;
 
   {
-    let IO.writer out = IO.file_writer(tmpfile, vec(IO.create));
+    let io::writer out = io::file_writer(tmpfile, vec(io::create));
     out.write_str(frood);
   }
 
-  let IO.reader inp = IO.file_reader(tmpfile);
+  let io::reader inp = io::file_reader(tmpfile);
   let str frood2 = inp.read_c_str();
   log frood2;
-  assert (Str.eq(frood, frood2));
+  assert (_str::eq(frood, frood2));
 }
 
 fn main(vec[str] argv) {
diff --git a/src/test/run-pass/lib-map.rs b/src/test/run-pass/lib-map.rs
index 1f956055..402ef108 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -1,32 +1,32 @@
 // -*- rust -*-
 
 use std;
-import std.Map;
-import std.Str;
-import std.UInt;
-import std.Util;
+import std::map;
+import std::_str;
+import std::_uint;
+import std::util;
 
 fn test_simple() {
   log "*** starting test_simple";
 
   fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
   fn hash_uint(&uint u) -> uint {
-    // FIXME: can't use std.Util.id since we'd be capturing a type param,
+    // FIXME: can't use std::util::id since we'd be capturing a type param,
     // and presently we can't close items over type params.
     ret u;
   }
 
-  let Map.hashfn[uint] hasher_uint = hash_uint;
-  let Map.eqfn[uint] eqer_uint = eq_uint;
+  let map::hashfn[uint] hasher_uint = hash_uint;
+  let map::eqfn[uint] eqer_uint = eq_uint;
 
-  let Map.hashfn[str] hasher_str = Str.hash;
-  let Map.eqfn[str] eqer_str = Str.eq;
+  let map::hashfn[str] hasher_str = _str::hash;
+  let map::eqfn[str] eqer_str = _str::eq;
 
 
   log "uint -> uint";
 
-  let Map.hashmap[uint, uint] hm_uu = Map.mk_hashmap[uint, uint](hasher_uint,
-                                                                 eqer_uint);
+  let map::hashmap[uint, uint] hm_uu =
+      map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
 
   assert (hm_uu.insert(10u, 12u));
   assert (hm_uu.insert(11u, 13u));
@@ -49,7 +49,7 @@ fn test_simple() {
 
   log "str -> uint";
 
-  let Map.hashmap[str, uint] hm_su = Map.mk_hashmap[str, uint](hasher_str,
+  let map::hashmap[str, uint] hm_su = map::mk_hashmap[str, uint](hasher_str,
                                                                eqer_str);
   assert (hm_su.insert("ten", 12u));
   assert (hm_su.insert(eleven, 13u));
@@ -70,42 +70,42 @@ fn test_simple() {
 
   log "uint -> str";
 
-  let Map.hashmap[uint, str] hm_us = Map.mk_hashmap[uint, str](hasher_uint,
+  let map::hashmap[uint, str] hm_us = map::mk_hashmap[uint, str](hasher_uint,
                                                                eqer_uint);
 
   assert (hm_us.insert(10u, "twelve"));
   assert (hm_us.insert(11u, "thirteen"));
   assert (hm_us.insert(12u, "fourteen"));
 
-  assert (Str.eq(hm_us.get(11u), "thirteen"));
-  assert (Str.eq(hm_us.get(12u), "fourteen"));
-  assert (Str.eq(hm_us.get(10u), "twelve"));
+  assert (_str::eq(hm_us.get(11u), "thirteen"));
+  assert (_str::eq(hm_us.get(12u), "fourteen"));
+  assert (_str::eq(hm_us.get(10u), "twelve"));
 
   assert (!hm_us.insert(12u, "fourteen"));
-  assert (Str.eq(hm_us.get(12u), "fourteen"));
+  assert (_str::eq(hm_us.get(12u), "fourteen"));
 
   assert (!hm_us.insert(12u, "twelve"));
-  assert (Str.eq(hm_us.get(12u), "twelve"));
+  assert (_str::eq(hm_us.get(12u), "twelve"));
 
 
   log "str -> str";
 
-  let Map.hashmap[str, str] hm_ss = Map.mk_hashmap[str, str](hasher_str,
+  let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str,
                                                              eqer_str);
 
   assert (hm_ss.insert(ten, "twelve"));
   assert (hm_ss.insert(eleven, "thirteen"));
   assert (hm_ss.insert(twelve, "fourteen"));
 
-  assert (Str.eq(hm_ss.get("eleven"), "thirteen"));
-  assert (Str.eq(hm_ss.get("twelve"), "fourteen"));
-  assert (Str.eq(hm_ss.get("ten"), "twelve"));
+  assert (_str::eq(hm_ss.get("eleven"), "thirteen"));
+  assert (_str::eq(hm_ss.get("twelve"), "fourteen"));
+  assert (_str::eq(hm_ss.get("ten"), "twelve"));
 
   assert (!hm_ss.insert("twelve", "fourteen"));
-  assert (Str.eq(hm_ss.get("twelve"), "fourteen"));
+  assert (_str::eq(hm_ss.get("twelve"), "fourteen"));
 
   assert (!hm_ss.insert("twelve", "twelve"));
-  assert (Str.eq(hm_ss.get("twelve"), "twelve"));
+  assert (_str::eq(hm_ss.get("twelve"), "twelve"));
 
   log "*** finished test_simple";
 }
@@ -120,7 +120,7 @@ fn test_growth() {
 
   fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
   fn hash_uint(&uint u) -> uint {
-    // FIXME: can't use std.Util.id since we'd be capturing a type param,
+    // FIXME: can't use std::util::id since we'd be capturing a type param,
     // and presently we can't close items over type params.
     ret u;
   }
@@ -128,16 +128,16 @@ fn test_growth() {
 
   log "uint -> uint";
 
-  let Map.hashfn[uint] hasher_uint = hash_uint;
-  let Map.eqfn[uint] eqer_uint = eq_uint;
-  let Map.hashmap[uint, uint] hm_uu = Map.mk_hashmap[uint, uint](hasher_uint,
-                                                                 eqer_uint);
+  let map::hashfn[uint] hasher_uint = hash_uint;
+  let map::eqfn[uint] eqer_uint = eq_uint;
+  let map::hashmap[uint, uint] hm_uu =
+      map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
 
   let uint i = 0u;
   while (i < num_to_insert) {
     assert (hm_uu.insert(i, i * i));
-    log "inserting " + UInt.to_str(i, 10u)
-      + " -> " + UInt.to_str(i * i, 10u);
+    log "inserting " + _uint::to_str(i, 10u)
+      + " -> " + _uint::to_str(i * i, 10u);
     i += 1u;
   }
 
@@ -145,8 +145,8 @@ fn test_growth() {
 
   i = 0u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm_uu.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm_uu.get(i), 10u);
     assert (hm_uu.get(i) == i * i);
     i += 1u;
   }
@@ -160,8 +160,8 @@ fn test_growth() {
 
   i = 0u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm_uu.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm_uu.get(i), 10u);
     assert (hm_uu.get(i) == i * i);
     i += 1u;
   }
@@ -169,16 +169,16 @@ fn test_growth() {
 
   log "str -> str";
 
-  let Map.hashfn[str] hasher_str = Str.hash;
-  let Map.eqfn[str] eqer_str = Str.eq;
-  let Map.hashmap[str, str] hm_ss = Map.mk_hashmap[str, str](hasher_str,
+  let map::hashfn[str] hasher_str = _str::hash;
+  let map::eqfn[str] eqer_str = _str::eq;
+  let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str,
                                                              eqer_str);
 
   i = 0u;
   while (i < num_to_insert) {
-    assert (hm_ss.insert(UInt.to_str(i, 2u), UInt.to_str(i * i, 2u)));
-    log "inserting \"" + UInt.to_str(i, 2u)
-      + "\" -> \"" + UInt.to_str(i * i, 2u) + "\"";
+    assert (hm_ss.insert(_uint::to_str(i, 2u), _uint::to_str(i * i, 2u)));
+    log "inserting \"" + _uint::to_str(i, 2u)
+      + "\" -> \"" + _uint::to_str(i * i, 2u) + "\"";
     i += 1u;
   }
 
@@ -187,20 +187,20 @@ fn test_growth() {
   i = 0u;
   while (i < num_to_insert) {
     log "get(\""
-      + UInt.to_str(i, 2u)
+      + _uint::to_str(i, 2u)
       + "\") = \""
-      + hm_ss.get(UInt.to_str(i, 2u)) + "\"";
+      + hm_ss.get(_uint::to_str(i, 2u)) + "\"";
 
-    assert (Str.eq(hm_ss.get(UInt.to_str(i, 2u)),
-                   UInt.to_str(i * i, 2u)));
+    assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)),
+                   _uint::to_str(i * i, 2u)));
     i += 1u;
   }
 
-  assert (hm_ss.insert(UInt.to_str(num_to_insert, 2u),
-                      UInt.to_str(17u, 2u)));
+  assert (hm_ss.insert(_uint::to_str(num_to_insert, 2u),
+                      _uint::to_str(17u, 2u)));
 
-  assert (Str.eq(hm_ss.get(UInt.to_str(num_to_insert, 2u)),
-                 UInt.to_str(17u, 2u)));
+  assert (_str::eq(hm_ss.get(_uint::to_str(num_to_insert, 2u)),
+                 _uint::to_str(17u, 2u)));
 
   log "-----";
 
@@ -208,10 +208,10 @@ fn test_growth() {
 
   i = 0u;
   while (i < num_to_insert) {
-    log "get(\"" + UInt.to_str(i, 2u) + "\") = \""
-      + hm_ss.get(UInt.to_str(i, 2u)) + "\"";
-    assert (Str.eq(hm_ss.get(UInt.to_str(i, 2u)),
-                   UInt.to_str(i * i, 2u)));
+    log "get(\"" + _uint::to_str(i, 2u) + "\") = \""
+      + hm_ss.get(_uint::to_str(i, 2u)) + "\"";
+    assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)),
+                   _uint::to_str(i * i, 2u)));
     i += 1u;
   }
 
@@ -234,15 +234,15 @@ fn test_removal() {
   assert (hash(2u) == hash(3u));
   assert (hash(0u) != hash(2u));
 
-  let Map.hashfn[uint] hasher = hash;
-  let Map.eqfn[uint] eqer = eq;
-  let Map.hashmap[uint, uint] hm = Map.mk_hashmap[uint, uint](hasher, eqer);
+  let map::hashfn[uint] hasher = hash;
+  let map::eqfn[uint] eqer = eq;
+  let map::hashmap[uint, uint] hm = map::mk_hashmap[uint, uint](hasher, eqer);
 
   let uint i = 0u;
   while (i < num_to_insert) {
     assert (hm.insert(i, i * i));
-    log "inserting " + UInt.to_str(i, 10u)
-      + " -> " + UInt.to_str(i * i, 10u);
+    log "inserting " + _uint::to_str(i, 10u)
+      + " -> " + _uint::to_str(i * i, 10u);
     i += 1u;
   }
 
@@ -279,8 +279,8 @@ fn test_removal() {
 
   i = 1u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm.get(i), 10u);
     assert (hm.get(i) == i * i);
     i += 2u;
   }
@@ -294,8 +294,8 @@ fn test_removal() {
 
   i = 1u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm.get(i), 10u);
     assert (hm.get(i) == i * i);
     i += 2u;
   }
@@ -305,8 +305,8 @@ fn test_removal() {
   i = 0u;
   while (i < num_to_insert) {
     assert (hm.insert(i, i * i));
-    log "inserting " + UInt.to_str(i, 10u)
-      + " -> " + UInt.to_str(i * i, 10u);
+    log "inserting " + _uint::to_str(i, 10u)
+      + " -> " + _uint::to_str(i * i, 10u);
     i += 2u;
   }
 
@@ -316,8 +316,8 @@ fn test_removal() {
 
   i = 0u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm.get(i), 10u);
     assert (hm.get(i) == i * i);
     i += 1u;
   }
@@ -333,8 +333,8 @@ fn test_removal() {
 
   i = 0u;
   while (i < num_to_insert) {
-    log "get(" + UInt.to_str(i, 10u) + ") = "
-      + UInt.to_str(hm.get(i), 10u);
+    log "get(" + _uint::to_str(i, 10u) + ") = "
+      + _uint::to_str(hm.get(i), 10u);
     assert (hm.get(i) == i * i);
     i += 1u;
   }
diff --git a/src/test/run-pass/lib-option.rs b/src/test/run-pass/lib-option.rs
index 417ab482..cf004f1d 100644
--- a/src/test/run-pass/lib-option.rs
+++ b/src/test/run-pass/lib-option.rs
@@ -1,5 +1,5 @@
 use std;
 
 fn main() {
-  auto x = std.Option.some[int](10);
+  auto x = std::option::some[int](10);
 }
diff --git a/src/test/run-pass/lib-qsort.rs b/src/test/run-pass/lib-qsort.rs
index aed5009d..2f086667 100644
--- a/src/test/run-pass/lib-qsort.rs
+++ b/src/test/run-pass/lib-qsort.rs
@@ -1,13 +1,13 @@
 use std;
 
 fn check_sort(vec[mutable int] v1, vec[mutable int] v2) {
-  auto len = std.Vec.len[int](v1);
+  auto len = std::_vec::len[int](v1);
 
   fn ltequal(&int a, &int b) -> bool {
     ret a <= b;
   }
   auto f = ltequal;
-  std.Sort.quick_sort[int](f, v1);
+  std::sort::quick_sort[int](f, v1);
   auto i = 0u;
   while (i < len) {
     log v2.(i);
diff --git a/src/test/run-pass/lib-rand.rs b/src/test/run-pass/lib-rand.rs
index e423bcba..388811bc 100644
--- a/src/test/run-pass/lib-rand.rs
+++ b/src/test/run-pass/lib-rand.rs
@@ -4,14 +4,14 @@
 // -*- rust -*-
 
 use std;
-import std.Rand;
+import std::rand;
 
 fn main() {
-  let Rand.rng r1 = Rand.mk_rng();
+  let rand::rng r1 = rand::mk_rng();
   log r1.next();
   log r1.next();
   {
-    auto r2 = Rand.mk_rng();
+    auto r2 = rand::mk_rng();
     log r1.next();
     log r2.next();
     log r1.next();
diff --git a/src/test/run-pass/lib-sha1.rs b/src/test/run-pass/lib-sha1.rs
index c89eca59..18ea4f38 100644
--- a/src/test/run-pass/lib-sha1.rs
+++ b/src/test/run-pass/lib-sha1.rs
@@ -5,9 +5,9 @@
 
 use std;
 
-import std.SHA1;
-import std.Vec;
-import std.Str;
+import std::sha1;
+import std::_vec;
+import std::_str;
 
 fn main() {
 
@@ -67,8 +67,8 @@ fn main() {
     auto tests = fips_180_1_tests + wikipedia_tests;
 
     fn check_vec_eq(vec[u8] v0, vec[u8] v1) {
-        assert (Vec.len[u8](v0) == Vec.len[u8](v1));
-        auto len = Vec.len[u8](v0);
+        assert (_vec::len[u8](v0) == _vec::len[u8](v1));
+        auto len = _vec::len[u8](v0);
         auto i = 0u;
         while (i < len) {
             auto a = v0.(i);
@@ -79,7 +79,7 @@ fn main() {
     }
 
     // Test that it works when accepting the message all at once
-    auto sh = SHA1.mk_sha1();
+    auto sh = sha1::mk_sha1();
     for (test t in tests) {
         sh.input_str(t.input);
         auto out = sh.result();
@@ -89,11 +89,11 @@ fn main() {
 
     // Test that it works when accepting the message in pieces
     for (test t in tests) {
-        auto len = Str.byte_len(t.input);
+        auto len = _str::byte_len(t.input);
         auto left = len;
         while (left > 0u) {
             auto take = (left + 1u) / 2u;
-            sh.input_str(Str.substr(t.input, len - left, take));
+            sh.input_str(_str::substr(t.input, len - left, take));
             left = left - take;
         }
         auto out = sh.result();
diff --git a/src/test/run-pass/lib-sort.rs b/src/test/run-pass/lib-sort.rs
index 145d0175..6ec266fa 100644
--- a/src/test/run-pass/lib-sort.rs
+++ b/src/test/run-pass/lib-sort.rs
@@ -1,12 +1,12 @@
 use std;
 
 fn check_sort(vec[int] v1, vec[int] v2) {
-  auto len = std.Vec.len[int](v1);
+  auto len = std::_vec::len[int](v1);
   fn lteq(&int a, &int b) -> bool {
     ret a <= b;
   }
   auto f = lteq;
-  auto v3 = std.Sort.merge_sort[int](f, v1);
+  auto v3 = std::sort::merge_sort[int](f, v1);
   auto i = 0u;
   while (i < len) {
     log v3.(i);
diff --git a/src/test/run-pass/lib-str-buf.rs b/src/test/run-pass/lib-str-buf.rs
index cd8ba9e9..af1148a5 100644
--- a/src/test/run-pass/lib-str-buf.rs
+++ b/src/test/run-pass/lib-str-buf.rs
@@ -4,14 +4,14 @@
 // -*- rust -*-
 
 use std;
-import std.Str;
+import std::_str;
 
 fn main() {
     auto s = "hello";
-    auto sb = Str.rustrt.str_buf(s);
-    auto s_cstr = Str.rustrt.str_from_cstr(sb);
-    assert (Str.eq(s_cstr, s));
-    auto s_buf = Str.rustrt.str_from_buf(sb, 5u);
-    assert (Str.eq(s_buf, s));
+    auto sb = str.rustrt.str_buf(s);
+    auto s_cstr = str.rustrt.str_from_cstr(sb);
+    assert (str.eq(s_cstr, s));
+    auto s_buf = str.rustrt.str_from_buf(sb, 5u);
+    assert (str.eq(s_buf, s));
 }
 
diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs
index 8985c22e..eff9eef1 100644
--- a/src/test/run-pass/lib-str.rs
+++ b/src/test/run-pass/lib-str.rs
@@ -2,38 +2,38 @@
 // xfail-stage0
 
 use std;
-import std.Str;
+import std::_str;
 
 fn test_bytes_len() {
-  assert (Str.byte_len("") == 0u);
-  assert (Str.byte_len("hello world") == 11u);
-  assert (Str.byte_len("\x63") == 1u);
-  assert (Str.byte_len("\xa2") == 2u);
-  assert (Str.byte_len("\u03c0") == 2u);
-  assert (Str.byte_len("\u2620") == 3u);
-  assert (Str.byte_len("\U0001d11e") == 4u);
+  assert (_str::byte_len("") == 0u);
+  assert (_str::byte_len("hello world") == 11u);
+  assert (_str::byte_len("\x63") == 1u);
+  assert (_str::byte_len("\xa2") == 2u);
+  assert (_str::byte_len("\u03c0") == 2u);
+  assert (_str::byte_len("\u2620") == 3u);
+  assert (_str::byte_len("\U0001d11e") == 4u);
 }
 
 fn test_index_and_rindex() {
-  assert (Str.index("hello", 'e' as u8) == 1);
-  assert (Str.index("hello", 'o' as u8) == 4);
-  assert (Str.index("hello", 'z' as u8) == -1);
-  assert (Str.rindex("hello", 'l' as u8) == 3);
-  assert (Str.rindex("hello", 'h' as u8) == 0);
-  assert (Str.rindex("hello", 'z' as u8) == -1);
+  assert (_str::index("hello", 'e' as u8) == 1);
+  assert (_str::index("hello", 'o' as u8) == 4);
+  assert (_str::index("hello", 'z' as u8) == -1);
+  assert (_str::rindex("hello", 'l' as u8) == 3);
+  assert (_str::rindex("hello", 'h' as u8) == 0);
+  assert (_str::rindex("hello", 'z' as u8) == -1);
 }
 
 fn test_split() {
   fn t(&str s, char c, int i, &str k) {
     log "splitting: " + s;
     log i;
-    auto v = Str.split(s, c as u8);
+    auto v = _str::split(s, c as u8);
     log "split to: ";
     for (str z in v) {
       log z;
     }
     log "comparing: " + v.(i) + " vs. " + k;
-    assert (Str.eq(v.(i), k));
+    assert (_str::eq(v.(i), k));
   }
   t("abc.hello.there", '.', 0, "abc");
   t("abc.hello.there", '.', 1, "hello");
@@ -46,7 +46,7 @@ fn test_split() {
 
 fn test_find() {
   fn t(&str haystack, &str needle, int i) {
-    let int j = Str.find(haystack,needle);
+    let int j = _str::find(haystack,needle);
     log "searched for " + needle;
     log j;
     assert (i == j);
@@ -60,8 +60,8 @@ fn test_find() {
 
 fn test_substr() {
   fn t(&str a, &str b, int start) {
-    assert (Str.eq(Str.substr(a, start as uint,
-                              Str.byte_len(b)), b));
+    assert (_str::eq(_str::substr(a, start as uint,
+                              _str::byte_len(b)), b));
   }
 
   t("hello", "llo", 2);
@@ -71,7 +71,7 @@ fn test_substr() {
 
 fn test_concat() {
   fn t(&vec[str] v, &str s) {
-    assert (Str.eq(Str.concat(v), s));
+    assert (_str::eq(_str::concat(v), s));
   }
 
   t(vec("you", "know", "I'm", "no", "good"), "youknowI'mnogood");
@@ -82,7 +82,7 @@ fn test_concat() {
 
 fn test_connect() {
   fn t(&vec[str] v, &str sep, &str s) {
-    assert (Str.eq(Str.connect(v, sep), s));
+    assert (_str::eq(_str::connect(v, sep), s));
   }
 
   t(vec("you", "know", "I'm", "no", "good"), " ", "you know I'm no good");
@@ -97,14 +97,14 @@ fn test_to_upper() {
   auto unicode = "\u65e5\u672c";
   auto input = "abcDEF" + unicode + "xyz:.;";
   auto expected = "ABCDEF" + unicode + "XYZ:.;";
-  auto actual = Str.to_upper(input);
-  assert (Str.eq(expected, actual));
+  auto actual = _str::to_upper(input);
+  assert (_str::eq(expected, actual));
 }
 
 fn test_slice() {
-  assert (Str.eq("ab", Str.slice("abc", 0u, 2u)));
-  assert (Str.eq("bc", Str.slice("abc", 1u, 3u)));
-  assert (Str.eq("", Str.slice("abc", 1u, 1u)));
+  assert (_str::eq("ab", _str::slice("abc", 0u, 2u)));
+  assert (_str::eq("bc", _str::slice("abc", 1u, 3u)));
+  assert (_str::eq("", _str::slice("abc", 1u, 1u)));
 
   fn a_million_letter_a() -> str {
     auto i = 0;
@@ -126,8 +126,8 @@ fn test_slice() {
     ret res;
   }
 
-  assert (Str.eq(half_a_million_letter_a(),
-                 Str.slice(a_million_letter_a(),
+  assert (_str::eq(half_a_million_letter_a(),
+                 _str::slice(a_million_letter_a(),
                            0u,
                            500000u)));
 }
diff --git a/src/test/run-pass/lib-task.rs b/src/test/run-pass/lib-task.rs
index 8e07962c..f1cca720 100644
--- a/src/test/run-pass/lib-task.rs
+++ b/src/test/run-pass/lib-task.rs
@@ -1,6 +1,6 @@
 use std;
-import std.Task;
+import std::_task;
 
 fn main() {
-  Task.sleep(1000000u);
+  _task::sleep(1000000u);
 }
\ No newline at end of file
diff --git a/src/test/run-pass/lib-uint.rs b/src/test/run-pass/lib-uint.rs
index 4f787745..3de24ba3 100644
--- a/src/test/run-pass/lib-uint.rs
+++ b/src/test/run-pass/lib-uint.rs
@@ -1,47 +1,47 @@
 // -*- rust -*-
 
 use std;
-import std.UInt;
+import std::_uint;
 
 fn main() {
-  assert (UInt.next_power_of_two(0u) == 0u);
-  assert (UInt.next_power_of_two(1u) == 1u);
-  assert (UInt.next_power_of_two(2u) == 2u);
-  assert (UInt.next_power_of_two(3u) == 4u);
-  assert (UInt.next_power_of_two(4u) == 4u);
-  assert (UInt.next_power_of_two(5u) == 8u);
-  assert (UInt.next_power_of_two(6u) == 8u);
-  assert (UInt.next_power_of_two(7u) == 8u);
-  assert (UInt.next_power_of_two(8u) == 8u);
-  assert (UInt.next_power_of_two(9u) == 16u);
-  assert (UInt.next_power_of_two(10u) == 16u);
-  assert (UInt.next_power_of_two(11u) == 16u);
-  assert (UInt.next_power_of_two(12u) == 16u);
-  assert (UInt.next_power_of_two(13u) == 16u);
-  assert (UInt.next_power_of_two(14u) == 16u);
-  assert (UInt.next_power_of_two(15u) == 16u);
-  assert (UInt.next_power_of_two(16u) == 16u);
-  assert (UInt.next_power_of_two(17u) == 32u);
-  assert (UInt.next_power_of_two(18u) == 32u);
-  assert (UInt.next_power_of_two(19u) == 32u);
-  assert (UInt.next_power_of_two(20u) == 32u);
-  assert (UInt.next_power_of_two(21u) == 32u);
-  assert (UInt.next_power_of_two(22u) == 32u);
-  assert (UInt.next_power_of_two(23u) == 32u);
-  assert (UInt.next_power_of_two(24u) == 32u);
-  assert (UInt.next_power_of_two(25u) == 32u);
-  assert (UInt.next_power_of_two(26u) == 32u);
-  assert (UInt.next_power_of_two(27u) == 32u);
-  assert (UInt.next_power_of_two(28u) == 32u);
-  assert (UInt.next_power_of_two(29u) == 32u);
-  assert (UInt.next_power_of_two(30u) == 32u);
-  assert (UInt.next_power_of_two(31u) == 32u);
-  assert (UInt.next_power_of_two(32u) == 32u);
-  assert (UInt.next_power_of_two(33u) == 64u);
-  assert (UInt.next_power_of_two(34u) == 64u);
-  assert (UInt.next_power_of_two(35u) == 64u);
-  assert (UInt.next_power_of_two(36u) == 64u);
-  assert (UInt.next_power_of_two(37u) == 64u);
-  assert (UInt.next_power_of_two(38u) == 64u);
-  assert (UInt.next_power_of_two(39u) == 64u);
+  assert (_uint::next_power_of_two(0u) == 0u);
+  assert (_uint::next_power_of_two(1u) == 1u);
+  assert (_uint::next_power_of_two(2u) == 2u);
+  assert (_uint::next_power_of_two(3u) == 4u);
+  assert (_uint::next_power_of_two(4u) == 4u);
+  assert (_uint::next_power_of_two(5u) == 8u);
+  assert (_uint::next_power_of_two(6u) == 8u);
+  assert (_uint::next_power_of_two(7u) == 8u);
+  assert (_uint::next_power_of_two(8u) == 8u);
+  assert (_uint::next_power_of_two(9u) == 16u);
+  assert (_uint::next_power_of_two(10u) == 16u);
+  assert (_uint::next_power_of_two(11u) == 16u);
+  assert (_uint::next_power_of_two(12u) == 16u);
+  assert (_uint::next_power_of_two(13u) == 16u);
+  assert (_uint::next_power_of_two(14u) == 16u);
+  assert (_uint::next_power_of_two(15u) == 16u);
+  assert (_uint::next_power_of_two(16u) == 16u);
+  assert (_uint::next_power_of_two(17u) == 32u);
+  assert (_uint::next_power_of_two(18u) == 32u);
+  assert (_uint::next_power_of_two(19u) == 32u);
+  assert (_uint::next_power_of_two(20u) == 32u);
+  assert (_uint::next_power_of_two(21u) == 32u);
+  assert (_uint::next_power_of_two(22u) == 32u);
+  assert (_uint::next_power_of_two(23u) == 32u);
+  assert (_uint::next_power_of_two(24u) == 32u);
+  assert (_uint::next_power_of_two(25u) == 32u);
+  assert (_uint::next_power_of_two(26u) == 32u);
+  assert (_uint::next_power_of_two(27u) == 32u);
+  assert (_uint::next_power_of_two(28u) == 32u);
+  assert (_uint::next_power_of_two(29u) == 32u);
+  assert (_uint::next_power_of_two(30u) == 32u);
+  assert (_uint::next_power_of_two(31u) == 32u);
+  assert (_uint::next_power_of_two(32u) == 32u);
+  assert (_uint::next_power_of_two(33u) == 64u);
+  assert (_uint::next_power_of_two(34u) == 64u);
+  assert (_uint::next_power_of_two(35u) == 64u);
+  assert (_uint::next_power_of_two(36u) == 64u);
+  assert (_uint::next_power_of_two(37u) == 64u);
+  assert (_uint::next_power_of_two(38u) == 64u);
+  assert (_uint::next_power_of_two(39u) == 64u);
 }
diff --git a/src/test/run-pass/lib-vec-str-conversions.rs b/src/test/run-pass/lib-vec-str-conversions.rs
index cd8b64a8..c85374bf 100644
--- a/src/test/run-pass/lib-vec-str-conversions.rs
+++ b/src/test/run-pass/lib-vec-str-conversions.rs
@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 use std;
-import std.Str;
-import std.Vec;
+import std::_str;
+import std::_vec;
 
 fn test_simple() {
   let str s1 = "All mimsy were the borogoves";
@@ -14,12 +14,12 @@ fn test_simple() {
    * working, but we should implement is_utf8 before that happens.
    */
 
-  let vec[u8] v = Str.bytes(s1);
-  let str s2 = Str.from_bytes(v);
+  let vec[u8] v = _str::bytes(s1);
+  let str s2 = _str::from_bytes(v);
 
   let uint i = 0u;
-  let uint n1 = Str.byte_len(s1);
-  let uint n2 = Vec.len[u8](v);
+  let uint n1 = _str::byte_len(s1);
+  let uint n2 = _vec::len[u8](v);
 
   assert (n1 == n2);
 
@@ -33,7 +33,7 @@ fn test_simple() {
   }
 
   log "refcnt is";
-  log Str.refcount(s1);
+  log _str::refcount(s1);
 }
 
 fn main() {
diff --git a/src/test/run-pass/lib-vec.rs b/src/test/run-pass/lib-vec.rs
index 0905652a..f7e6157a 100644
--- a/src/test/run-pass/lib-vec.rs
+++ b/src/test/run-pass/lib-vec.rs
@@ -1,8 +1,8 @@
 use std;
 
 fn test_init_elt() {
-  let vec[uint] v = std.Vec.init_elt[uint](5u, 3u);
-  assert (std.Vec.len[uint](v) == 3u);
+  let vec[uint] v = std::_vec::init_elt[uint](5u, 3u);
+  assert (std::_vec::len[uint](v) == 3u);
   assert (v.(0) == 5u);
   assert (v.(1) == 5u);
   assert (v.(2) == 5u);
@@ -13,8 +13,8 @@ fn id(uint x) -> uint {
 }
 fn test_init_fn() {
   let fn(uint)->uint op = id;
-  let vec[uint] v = std.Vec.init_fn[uint](op, 5u);
-  assert (std.Vec.len[uint](v) == 5u);
+  let vec[uint] v = std::_vec::init_fn[uint](op, 5u);
+  assert (std::_vec::len[uint](v) == 5u);
   assert (v.(0) == 0u);
   assert (v.(1) == 1u);
   assert (v.(2) == 2u);
@@ -24,17 +24,17 @@ fn test_init_fn() {
 
 fn test_slice() {
   let vec[int] v = vec(1,2,3,4,5);
-  auto v2 = std.Vec.slice[int](v, 2u, 4u);
-  assert (std.Vec.len[int](v2) == 2u);
+  auto v2 = std::_vec::slice[int](v, 2u, 4u);
+  assert (std::_vec::len[int](v2) == 2u);
   assert (v2.(0) == 3);
   assert (v2.(1) == 4);
 }
 
 fn test_map() {
   fn square(&int x) -> int { ret x * x; }
-  let std.Option.operator[int, int] op = square;
+  let std::option::operator[int, int] op = square;
   let vec[int] v = vec(1, 2, 3, 4, 5);
-  let vec[int] s = std.Vec.map[int, int](op, v);
+  let vec[int] s = std::_vec::map[int, int](op, v);
   let int i = 0;
   while (i < 5) {
     assert (v.(i) * v.(i) == s.(i));
@@ -47,7 +47,7 @@ fn test_map2() {
   auto f = times;
   auto v0 = vec(1, 2, 3, 4, 5);
   auto v1 = vec(5, 4, 3, 2, 1);
-  auto u = std.Vec.map2[int,int,int](f, v0, v1);
+  auto u = std::_vec::map2[int,int,int](f, v0, v1);
 
   auto i = 0;
   while (i < 5) {
diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs
index b5eff76f..7a884e41 100644
--- a/src/test/run-pass/mlist-cycle.rs
+++ b/src/test/run-pass/mlist-cycle.rs
@@ -16,6 +16,6 @@ fn main() {
   let @cell first = @tup(mutable @nil());
   let @cell second = @tup(mutable @link(first));
   first._0 = @link(second);
-  std.Sys.rustrt.gc();
+  std::sys.rustrt.gc();
   let @cell third = @tup(mutable @nil());
 }
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 5919abdc..c63220df 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -11,7 +11,7 @@ fn main() {
   grow(v);
   grow(v);
   grow(v);
-  auto len = std.Vec.len[int](v);
+  auto len = std::_vec::len[int](v);
   log len;
   assert (len == (3 as uint));
 }
diff --git a/src/test/run-pass/native2.rs b/src/test/run-pass/native2.rs
index 4815345a..df2540ae 100644
--- a/src/test/run-pass/native2.rs
+++ b/src/test/run-pass/native2.rs
@@ -10,7 +10,7 @@ native mod zed {
 }
 
 native mod libc = "libc.dylib" {
-    fn write(int fd, rustrt.vbuf buf, uint count) -> int;
+    fn write(int fd, rustrt::vbuf buf, uint count) -> int;
 }
 
 native "cdecl" mod baz {
diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs
index cb244cc8..c44c96e5 100644
--- a/src/test/run-pass/nested-pattern.rs
+++ b/src/test/run-pass/nested-pattern.rs
@@ -1,13 +1,13 @@
 // 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 std::option;
+import std::option::some;
+import std::option::none;
 
 tag t {
   foo(int, uint);
-  bar(int, Option.t[int]);
+  bar(int, option::t[int]);
 }
 
 fn nested(t o) {
diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs
index e94d32eb..6b06e727 100644
--- a/src/test/run-pass/path.rs
+++ b/src/test/run-pass/path.rs
@@ -4,5 +4,5 @@ mod foo {
 }
 
 fn main(vec[str] args) {
-  foo.bar(0u);
+  foo::bar(0u);
 }
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index b6c545b2..b742af7c 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -5,9 +5,9 @@
 
 use std;
 
-import std.Option;
-import std.UInt;
-import std.Vec;
+import std::option;
+import std::_uint;
+import std::_vec;
 
 // A 12-byte unit to send over the channel
 type record = rec(u32 val1, u32 val2, u32 val3);
@@ -33,7 +33,7 @@ fn test_grow() {
 
     let record val = rec(val1=0u32, val2=0u32, val3=0u32);
 
-    for each (uint i in UInt.range(0u, 100u)) {
+    for each (uint i in _uint::range(0u, 100u)) {
         mychan <| val;
     }
 }
@@ -53,11 +53,11 @@ fn test_shrink2() {
 
     let record val = rec(val1=0u32, val2=0u32, val3=0u32);
 
-    for each (uint i in UInt.range(0u, 100u)) {
+    for each (uint i in _uint::range(0u, 100u)) {
         mychan <| val;
     }
 
-    for each (uint i in UInt.range(0u, 100u)) {
+    for each (uint i in _uint::range(0u, 100u)) {
         auto x <- myport;
     }
 }
@@ -67,7 +67,7 @@ fn test_rotate() {
     let port[record] myport = port();
     auto mychan = chan(myport);
 
-    for each (uint i in UInt.range(0u, 100u)) {
+    for each (uint i in _uint::range(0u, 100u)) {
         auto val = rec(val1=i as u32,
                        val2=i as u32,
                        val3=i as u32);
@@ -86,15 +86,15 @@ fn test_rotate_grow() {
     let port[record] myport = port();
     auto mychan = chan(myport);
 
-    for each (uint j in UInt.range(0u, 10u)) {
-        for each (uint i in UInt.range(0u, 10u)) {
+    for each (uint j in _uint::range(0u, 10u)) {
+        for each (uint i in _uint::range(0u, 10u)) {
             let record val = rec(val1=i as u32,
                                  val2=i as u32,
                                  val3=i as u32);
             mychan <| val;
         }
 
-        for each (uint i in UInt.range(0u, 10u)) {
+        for each (uint i in _uint::range(0u, 10u)) {
             auto x <- myport;
             assert (x.val1 == i as u32);
             assert (x.val2 == i as u32);
diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index 9f95ec95..b4bd6017 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -2,7 +2,7 @@
 // xfail-stage1
 // xfail-stage2
 fn main() {
-  auto x = spawn m.child(10);
+  auto x = spawn m::child(10);
   join x;
 }
 mod m {
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index afca72a8..ed2e3a7a 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std.Str;
+import std::_str;
 
 fn test1() {
   let str s = "hello";
@@ -20,8 +20,8 @@ fn test2() {
   log a;
   log b;
 
-  assert (Str.eq(a, "abcABCabc"));
-  assert (Str.eq(b, "ABCabcABC"));
+  assert (_str::eq(a, "abcABCabc"));
+  assert (_str::eq(b, "ABCabcABC"));
 }
 
 fn main() {
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 2e49e219..f0da72a3 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -1,11 +1,11 @@
 // xfail-boot
 use std;
-import std.Str;
+import std::_str;
 
 fn test(str actual, str expected) {
   log actual;
   log expected;
-  assert (Str.eq(actual, expected));
+  assert (_str::eq(actual, expected));
 }
 
 fn main() {
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index c8ebdd19..8adab6e9 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -6,7 +6,7 @@ fn main() -> () {
 }
 
 fn start() {
-    log "Started / Finished Task.";
+    log "Started / Finished task.";
 }
 
 fn test00() {
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index d4a135c2..2aa38b86 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -3,14 +3,14 @@
 // xfail-stage1
 // xfail-stage2
 use std;
-import std.Task;
+import std::_task;
 
 fn main() -> () {
     test00();
 }
 
 fn start(int task_number) {
-    log "Started / Finished Task.";
+    log "Started / Finished task.";
 }
     
 fn test00() {    
@@ -18,10 +18,10 @@ fn test00() {
     let task t = spawn thread "child" start(i);
     
     // Sleep long enough for the task to finish.
-    Task.sleep(10000u);
+    _task::sleep(10000u);
     
     // Try joining tasks that have already finished.
     join t;
     
-    log "Joined Task.";
+    log "Joined task.";
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-13-thread.rs b/src/test/run-pass/task-comm-13-thread.rs
index fedc516b..72f3c956 100644
--- a/src/test/run-pass/task-comm-13-thread.rs
+++ b/src/test/run-pass/task-comm-13-thread.rs
@@ -2,7 +2,7 @@
 // xfail-stage1
 // xfail-stage2
 use std;
-import std.Task;
+import std::_task;
 
 fn start(chan[int] c, int start, int number_of_messages) {
     let int i = 0;
@@ -17,5 +17,5 @@ fn main() -> () {
     let port[int] p = port();
     let task a = spawn thread "start" start(chan(p), 0, 10);
     join a;
-    log "Joined Task";
+    log "Joined task";
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index 1bf5d1f5..c6de8533 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -2,7 +2,7 @@
 // xfail-stage1
 // xfail-stage2
 use std;
-import std.Task;
+import std::_task;
 
 fn start(chan[int] c, int start, int number_of_messages) {
     let int i = 0;
@@ -17,5 +17,5 @@ fn main() -> () {
     let port[int] p = port();
     let task a = spawn "start" start(chan(p), 0, 10);
     join a;
-    log "Joined Task";
+    log "Joined task";
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 74faa149..7199db0c 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -97,12 +97,12 @@ fn test03() {
 }
 
 fn test04_start() {
-    log "Started Task";
+    log "Started task";
     let int i = 1024 * 1024 * 64;
     while (i > 0) {
         i = i - 1;
     }
-    log "Finished Task";
+    log "Finished task";
 }
 
 fn test04() {
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index d39a2064..fbc608ae 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -2,7 +2,7 @@
 // xfail-stage1
 // xfail-stage2
 
-import size_of = std.Sys.rustrt.size_of;
+import size_of = std::sys.rustrt.size_of;
 
 use std;
 
diff --git a/src/test/run-pass/use-import-export.rs b/src/test/run-pass/use-import-export.rs
index 3e047149..f9ac5345 100644
--- a/src/test/run-pass/use-import-export.rs
+++ b/src/test/run-pass/use-import-export.rs
@@ -15,7 +15,7 @@ mod bar {
 }
 
 fn main() {
-  foo.x();
-  bar.y();
+  foo::x();
+  bar::y();
 }
 
diff --git a/src/test/run-pass/use.rs b/src/test/run-pass/use.rs
index 3d1a6947..ee8ae10a 100644
--- a/src/test/run-pass/use.rs
+++ b/src/test/run-pass/use.rs
@@ -7,8 +7,8 @@ use zed(name = "std");
 use bar(name = "std", ver = "0.0.1");
 
 // FIXME: commented out since resolve doesn't know how to handle crates yet.
-// import std.Str;
-// import x = std.Str;
+// import std::str;
+// import x = std::str;
 
 mod baz {
   use std;
@@ -16,8 +16,8 @@ mod baz {
   use zed(name = "std");
   use bar(name = "std", ver = "0.0.1");
 
-  // import std.Str;
-  // import x = std.Str;
+  // import std::str;
+  // import x = std::str;
 }
 
 fn main() {
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index 877c416b..3281f448 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -8,10 +8,10 @@ use std (name = "std",
          uuid = _, ver = _);
 
 fn main() {
-  auto s = std.Str.alloc(10 as uint);
+  auto s = std::str.alloc(10 as uint);
   s += "hello ";
   log s;
   s += "there";
   log s;
-  auto z = std.Vec.alloc[int](10 as uint);
+  auto z = std::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 95cbc64e..a79294ec 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -2,34 +2,34 @@
 // xfail-stage1
 // xfail-stage2
 use std;
-import std.Str;
-import std.Vec;
-import std.IO;
+import std::_str;
+import std::_vec;
+import std::io;
 
 fn main() {
   // Chars of 1, 2, 3, and 4 bytes
   let vec[char] chs = vec('e', 'é', '€', 0x10000 as char);
-  let str s = Str.from_chars(chs);
+  let str s = _str::from_chars(chs);
 
-  assert (Str.byte_len(s) == 10u);
-  assert (Str.char_len(s) == 4u);
-  assert (Vec.len[char](Str.to_chars(s)) == 4u);
-  assert (Str.eq(Str.from_chars(Str.to_chars(s)), s));
-  assert (Str.char_at(s, 0u) == 'e');
-  assert (Str.char_at(s, 1u) == 'é');
+  assert (_str::byte_len(s) == 10u);
+  assert (_str::char_len(s) == 4u);
+  assert (_vec::len[char](_str::to_chars(s)) == 4u);
+  assert (_str::eq(_str::from_chars(_str::to_chars(s)), s));
+  assert (_str::char_at(s, 0u) == 'e');
+  assert (_str::char_at(s, 1u) == 'é');
 
-  assert (Str.is_utf8(Str.bytes(s)));
-  assert (!Str.is_utf8(vec(0x80_u8)));
-  assert (!Str.is_utf8(vec(0xc0_u8)));
-  assert (!Str.is_utf8(vec(0xc0_u8, 0x10_u8)));
+  assert (_str::is_utf8(_str::bytes(s)));
+  assert (!_str::is_utf8(vec(0x80_u8)));
+  assert (!_str::is_utf8(vec(0xc0_u8)));
+  assert (!_str::is_utf8(vec(0xc0_u8, 0x10_u8)));
 
   auto stack = "a×c€";
-  assert (Str.pop_char(stack) == '€');
-  assert (Str.pop_char(stack) == 'c');
-  Str.push_char(stack, 'u');
-  assert (Str.eq(stack, "a×u"));
-  assert (Str.shift_char(stack) == 'a');
-  assert (Str.shift_char(stack) == '×');
-  Str.unshift_char(stack, 'ß');
-  assert (Str.eq(stack, "ßu"));
+  assert (_str::pop_char(stack) == '€');
+  assert (_str::pop_char(stack) == 'c');
+  _str::push_char(stack, 'u');
+  assert (_str::eq(stack, "a×u"));
+  assert (_str::shift_char(stack) == 'a');
+  assert (_str::shift_char(stack) == '×');
+  _str::unshift_char(stack, 'ß');
+  assert (_str::eq(stack, "ßu"));
 }
diff --git a/src/test/run-pass/vec-alloc-append.rs b/src/test/run-pass/vec-alloc-append.rs
index 4327e789..d0ca6ab9 100644
--- a/src/test/run-pass/vec-alloc-append.rs
+++ b/src/test/run-pass/vec-alloc-append.rs
@@ -6,7 +6,7 @@
 use std;
 
 fn slice[T](vec[T] e) {
-  let vec[T] result = std.Vec.alloc[T](1 as uint);
+  let vec[T] result = std::vec.alloc[T](1 as uint);
   log "alloced";
   result += e;
   log "appended";
diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs
index cd87ec23..dc36799b 100644
--- a/src/test/run-pass/vec-append.rs
+++ b/src/test/run-pass/vec-append.rs
@@ -4,11 +4,11 @@
 // -*- rust -*-
 
 use std;
-import std.Str;
-import std.Vec;
+import std::_str;
+import std::_vec;
 
 
-// FIXME: import std.Dbg.const_refcount. Currently
+// FIXME: import std::dbg::const_refcount. Currently
 // cross-crate const references don't work.
 const uint const_refcount = 0x7bad_face_u;
 
@@ -53,30 +53,30 @@ fn slow_growth2_helper(str s) {   // ref up: s
     let vec[str] v = vec(mumble); // ref up: v, mumble
     let acc a = acc(v);           // ref up: a, v
 
-    log Vec.refcount[str](v);
-    assert (Vec.refcount[str](v) == 2u);
+    log _vec::refcount[str](v);
+    assert (_vec::refcount[str](v) == 2u);
 
     a.add(s);                     // ref up: mumble, s.  ref down: v
 
-    log Vec.refcount[str](v);
-    log Str.refcount(s);
-    log Str.refcount(mumble);
+    log _vec::refcount[str](v);
+    log _str::refcount(s);
+    log _str::refcount(mumble);
 
-    assert (Vec.refcount[str](v) == 1u);
-    assert (Str.refcount(s) == const_refcount);
-    assert (Str.refcount(mumble) == const_refcount);
+    assert (_vec::refcount[str](v) == 1u);
+    assert (_str::refcount(s) == const_refcount);
+    assert (_str::refcount(mumble) == const_refcount);
 
     log v.(0);
-    log Vec.len[str](v);
-    assert (Str.eq(v.(0), mumble));
-    assert (Vec.len[str](v) == 1u);
+    log _vec::len[str](v);
+    assert (_str::eq(v.(0), mumble));
+    assert (_vec::len[str](v) == 1u);
   }                               // ref down: a, mumble, s, v
 
-  log Str.refcount(s);
-  log Str.refcount(mumble);
+  log _str::refcount(s);
+  log _str::refcount(mumble);
 
-  assert (Str.refcount(s) == const_refcount);
-  assert (Str.refcount(mumble) == const_refcount);
+  assert (_str::refcount(s) == const_refcount);
+  assert (_str::refcount(mumble) == const_refcount);
 
   log mumble;
   log ss;
@@ -85,8 +85,8 @@ fn slow_growth2_helper(str s) {   // ref up: s
 fn slow_growth2() {
   let str s = "hi";               // ref up: s
   slow_growth2_helper(s);
-  log Str.refcount(s);
-  assert (Str.refcount(s) == const_refcount);
+  log _str::refcount(s);
+  assert (_str::refcount(s) == const_refcount);
 }
 
 fn main() {
diff --git a/src/test/run-pass/vec-ref-count.rs b/src/test/run-pass/vec-ref-count.rs
index 4534a861..86ba642b 100644
--- a/src/test/run-pass/vec-ref-count.rs
+++ b/src/test/run-pass/vec-ref-count.rs
@@ -1,12 +1,12 @@
 use std;
-import std.Vec;
+import std::_vec;
 
 fn main() {
     auto v = vec(1, 2, 3);
-    log_err Vec.refcount[int](v);
-    log_err Vec.refcount[int](v);
-    log_err Vec.refcount[int](v);
-    assert (Vec.refcount[int](v) == 1u || Vec.refcount[int](v) == 2u);
-    assert (Vec.refcount[int](v) == 1u || Vec.refcount[int](v) == 2u);
+    log_err _vec::refcount[int](v);
+    log_err _vec::refcount[int](v);
+    log_err _vec::refcount[int](v);
+    assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u);
+    assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u);
 }