Finally rename std::_xxx to std::xxx

Except for _task, which is still a keyword.

29 files changed, 268 insertions, 268 deletions

diff --git a/src/test/bench/99-bottles/99bob-iter.rs b/src/test/bench/99-bottles/99bob-iter.rs
index 5aa3dc2f544..37194a39e51 100644
--- a/src/test/bench/99-bottles/99bob-iter.rs
+++ b/src/test/bench/99-bottles/99bob-iter.rs
@@ -3,8 +3,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::_int;
-import std::_str;
+import std::int;
+import std::str;
 
 fn b1() -> str {
   ret "# of beer on the wall, # of beer.";
@@ -32,15 +32,15 @@ case (1) {
     ns = "1 bottle";
   }
  case (_) {
-    ns = _int::to_str(n, 10u) + " bottles";
+    ns = int::to_str(n, 10u) + " bottles";
   }
   }
-  while (i < _str::byte_len(t)) {
+  while (i < str::byte_len(t)) {
     if (t.(i) == ('#' as u8)) {
       b += ns;
     }
     else {
-      _str::push_byte(b, t.(i));
+      str::push_byte(b, t.(i));
     }
     i += 1u;
   }
diff --git a/src/test/bench/99-bottles/99bob-pattern.rs b/src/test/bench/99-bottles/99bob-pattern.rs
index 311fca460c8..96d61e8e232 100644
--- a/src/test/bench/99-bottles/99bob-pattern.rs
+++ b/src/test/bench/99-bottles/99bob-pattern.rs
@@ -3,8 +3,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::_int;
-import std::_str;
+import std::int;
+import std::str;
 
 tag bottle { none; dual; single; multiple(int);}
 
@@ -25,8 +25,8 @@ fn show(bottle b) {
       log "Take one down and pass it around, 1 bottle of beer on the wall.";
     }
     case (multiple(?n)) {
-      let str nb =  _int::to_str(n, 10u);
-      let str mb = _int::to_str(n - 1, 10u);
+      let str nb =  int::to_str(n, 10u);
+      let str mb = int::to_str(n - 1, 10u);
       log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
       log "Take one down and pass it around, " 
         + mb + " bottles of beer on the wall.";
diff --git a/src/test/bench/99-bottles/99bob-simple.rs b/src/test/bench/99-bottles/99bob-simple.rs
index 569b076a5ec..6aa6d6b1e2e 100644
--- a/src/test/bench/99-bottles/99bob-simple.rs
+++ b/src/test/bench/99-bottles/99bob-simple.rs
@@ -3,8 +3,8 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::_int;
-import std::_str;
+import std::int;
+import std::str;
 
 fn b1() -> str {
   ret "# of beer on the wall, # of beer.";
@@ -31,15 +31,15 @@ case (1) {
     ns = "1 bottle";
   }
  case (_) {
-    ns = _int::to_str(n, 10u) + " bottles";
+    ns = int::to_str(n, 10u) + " bottles";
   }
   }
-  while (i < _str::byte_len(t)) {
+  while (i < str::byte_len(t)) {
     if (t.(i) == ('#' as u8)) {
       b += ns;
     }
     else {
-      _str::push_byte(b, t.(i));
+      str::push_byte(b, t.(i));
     }
     i += 1u;
   }
diff --git a/src/test/bench/99-bottles/99bob-tail.rs b/src/test/bench/99-bottles/99bob-tail.rs
index 202b653b78f..8da4a5b76b7 100644
--- a/src/test/bench/99-bottles/99bob-tail.rs
+++ b/src/test/bench/99-bottles/99bob-tail.rs
@@ -3,13 +3,13 @@
  * http://99-bottles-of-beer.net/
  */
 use std;
-import std::_int;
-import std::_str;
+import std::int;
+import std::str;
 
 fn main() {
   fn multiple(int n) {
-    let str nb =  _int::to_str(n, 10u);
-    let str mb =  _int::to_str(n - 1, 10u);
+    let str nb =  int::to_str(n, 10u);
+    let str mb =  int::to_str(n - 1, 10u);
     log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
     log "Take one down and pass it around, " 
       + mb + " bottles of beer on the wall.";
diff --git a/src/test/bench/shootout/binarytrees.rs b/src/test/bench/shootout/binarytrees.rs
index 735ac2d506e..ef0de64363c 100644
--- a/src/test/bench/shootout/binarytrees.rs
+++ b/src/test/bench/shootout/binarytrees.rs
@@ -1,6 +1,6 @@
 use std;
 
-import std::_int;
+import std::int;
 
 tag tree {
   nil;
@@ -49,7 +49,7 @@ fn main() {
 
   auto depth = min_depth;
   while (depth <= max_depth) {
-    auto iterations = _int::pow(2, (max_depth - depth + min_depth) as uint);
+    auto iterations = int::pow(2, (max_depth - depth + min_depth) as uint);
     auto chk = 0;
 
     auto i = 1;
diff --git a/src/test/bench/shootout/fannkuchredux.rs b/src/test/bench/shootout/fannkuchredux.rs
index 0d24d338202..cca3592ce68 100644
--- a/src/test/bench/shootout/fannkuchredux.rs
+++ b/src/test/bench/shootout/fannkuchredux.rs
@@ -2,8 +2,8 @@
 
 use std;
 
-import std::_int;
-import std::_vec;
+import std::int;
+import std::vec;
 
 fn fannkuch(int n) -> int {
 
@@ -12,9 +12,9 @@ fn fannkuch(int n) -> int {
   }
   auto perm1init_ = perm1init; // Rustboot workaround
 
-  auto perm = _vec::init_elt(0, n as uint);
-  auto perm1 = _vec::init_fn(perm1init_, n as uint);
-  auto count = _vec::init_elt(0, n as uint);
+  auto perm = vec::init_elt(0, n as uint);
+  auto perm1 = vec::init_fn(perm1init_, n as uint);
+  auto count = vec::init_elt(0, n as uint);
 
   auto f = 0;
   auto i = 0;
diff --git a/src/test/bench/shootout/fasta.rs b/src/test/bench/shootout/fasta.rs
index b7a890971e3..1fc7ef43be3 100644
--- a/src/test/bench/shootout/fasta.rs
+++ b/src/test/bench/shootout/fasta.rs
@@ -7,10 +7,10 @@
  * http://shootout.alioth.debian.org/
  */
 use std;
-import std::_vec;
-import std::_str;
-import std::_uint;
-import std::_int;
+import std::vec;
+import std::str;
+import std::uint;
+import std::int;
 
 fn LINE_LENGTH() -> uint {
   ret 60u;
@@ -54,21 +54,21 @@ fn select_random(u32 r, vec[aminoacids] genelist) -> char {
       ret v.(hi)._0;
     }
   }
-  ret bisect(genelist, 0u, _vec::len[aminoacids](genelist) - 1u, r);
+  ret bisect(genelist, 0u, vec::len[aminoacids](genelist) - 1u, r);
 }
 
 fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
   log(">" + id + " " + desc);
   auto rng = myrandom(std::rand::mk_rng().next());
   let str op = "";
-  for each (uint i in _uint::range(0u, n as uint)) {
-    _str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
-    if (_str::byte_len(op) >= LINE_LENGTH()) {
+  for each (uint i in uint::range(0u, n as uint)) {
+    str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
+    if (str::byte_len(op) >= LINE_LENGTH()) {
       log(op);
       op = "";
     }
   }
-  if (_str::byte_len(op) > 0u) {
+  if (str::byte_len(op) > 0u) {
     log(op);
   }
 }
@@ -76,16 +76,16 @@ fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
 fn make_repeat_fasta(str id, str desc, str s, int n) {
   log(">" + id + " " + desc);
   let str op = "";
-  let uint sl = _str::byte_len(s);
-  for each (uint i in _uint::range(0u, n as uint)) {
+  let uint sl = str::byte_len(s);
+  for each (uint i in uint::range(0u, n as uint)) {
 
-    _str::push_byte(op, s.(i % sl));
-    if (_str::byte_len(op) >= LINE_LENGTH()) {
+    str::push_byte(op, s.(i % sl));
+    if (str::byte_len(op) >= LINE_LENGTH()) {
       log(op);
       op = "";
     }
   }
-  if (_str::byte_len(op) > 0u) {
+  if (str::byte_len(op) > 0u) {
     log(op);
   }
 }
diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index a59248ebfa8..fafa0bf7a60 100644
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 use std;
-import std::_str;
+import std::str;
 
 // FIXME: import std::dbg.const_refcount. Currently
 // cross-crate const references don't work.
@@ -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/box-inside-if.rs b/src/test/run-pass/box-inside-if.rs
index 21a2a02a30b..94e709dccbc 100644
--- a/src/test/run-pass/box-inside-if.rs
+++ b/src/test/run-pass/box-inside-if.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 // xfail-stage0
 use std;
-import std::_vec;
+import std::vec;
 
 fn some_vec(int x) -> vec[int] {
   ret [];
diff --git a/src/test/run-pass/box-inside-if2.rs b/src/test/run-pass/box-inside-if2.rs
index 4aa7201bc6b..cf319c90562 100644
--- a/src/test/run-pass/box-inside-if2.rs
+++ b/src/test/run-pass/box-inside-if2.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 // xfail-stage0
 use std;
-import std::_vec;
+import std::vec;
 
 fn some_vec(int x) -> vec[int] {
   ret [];
diff --git a/src/test/run-pass/lib-bitv.rs b/src/test/run-pass/lib-bitv.rs
index 706f3c22cd5..8dddc281775 100644
--- a/src/test/run-pass/lib-bitv.rs
+++ b/src/test/run-pass/lib-bitv.rs
@@ -1,5 +1,5 @@
 use std;
-import std::_vec;
+import std::vec;
 import std::bitv;
 
 fn test_0_elements() {
@@ -7,7 +7,7 @@ fn test_0_elements() {
   auto exp;
 
   act = bitv::create(0u, false);
-  exp = _vec::init_elt[uint](0u, 0u);
+  exp = vec::init_elt[uint](0u, 0u);
   // FIXME: why can't I write vec[uint]()?
   assert (bitv::eq_vec(act, exp));
 }
diff --git a/src/test/run-pass/lib-int.rs b/src/test/run-pass/lib-int.rs
index 20d70ccf756..cd525f67c56 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 3462e93f7c5..c7561ecc153 100644
--- a/src/test/run-pass/lib-io.rs
+++ b/src/test/run-pass/lib-io.rs
@@ -5,7 +5,7 @@
 
 use std;
 import std::io;
-import std::_str;
+import std::str;
 
 fn test_simple(str tmpfilebase) {
   let str tmpfile = tmpfilebase + ".tmp";
@@ -21,7 +21,7 @@ fn test_simple(str tmpfilebase) {
   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 402ef108149..fcded563618 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -2,8 +2,8 @@
 
 use std;
 import std::map;
-import std::_str;
-import std::_uint;
+import std::str;
+import std::uint;
 import std::util;
 
 fn test_simple() {
@@ -19,8 +19,8 @@ fn test_simple() {
   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";
@@ -77,15 +77,15 @@ fn test_simple() {
   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";
@@ -97,15 +97,15 @@ fn test_simple() {
   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";
 }
@@ -136,8 +136,8 @@ fn test_growth() {
   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::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;
   }
 
@@ -241,8 +241,8 @@ fn test_removal() {
   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-qsort.rs b/src/test/run-pass/lib-qsort.rs
index 473950cd864..53afba476a9 100644
--- a/src/test/run-pass/lib-qsort.rs
+++ b/src/test/run-pass/lib-qsort.rs
@@ -1,7 +1,7 @@
 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;
diff --git a/src/test/run-pass/lib-sha1.rs b/src/test/run-pass/lib-sha1.rs
index 7f137cb871c..1c9f843cfad 100644
--- a/src/test/run-pass/lib-sha1.rs
+++ b/src/test/run-pass/lib-sha1.rs
@@ -5,8 +5,8 @@
 use std;
 
 import std::sha1;
-import std::_vec;
-import std::_str;
+import std::vec;
+import std::str;
 
 fn main() {
 
@@ -66,8 +66,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);
@@ -88,11 +88,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 fe0c9e9473f..b63feae4fd7 100644
--- a/src/test/run-pass/lib-sort.rs
+++ b/src/test/run-pass/lib-sort.rs
@@ -1,7 +1,7 @@
 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;
   }
diff --git a/src/test/run-pass/lib-str-buf.rs b/src/test/run-pass/lib-str-buf.rs
index af1148a5f8a..a401838000c 100644
--- a/src/test/run-pass/lib-str-buf.rs
+++ b/src/test/run-pass/lib-str-buf.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 
 use std;
-import std::_str;
+import std::str;
 
 fn main() {
     auto s = "hello";
diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs
index 185694a25a1..a7c3cac8113 100644
--- a/src/test/run-pass/lib-str.rs
+++ b/src/test/run-pass/lib-str.rs
@@ -1,38 +1,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");
@@ -45,7 +45,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);
@@ -59,8 +59,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);
@@ -70,7 +70,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(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
@@ -81,7 +81,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(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
@@ -96,14 +96,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;
@@ -125,8 +125,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-uint.rs b/src/test/run-pass/lib-uint.rs
index 3de24ba3d49..e9618c4abb0 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 c85374bf3cd..10783b4fb2d 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 63e903d2d8e..af49eacf4c4 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,8 +24,8 @@ fn test_init_fn() {
 
 fn test_slice() {
   let vec[int] v = [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);
 }
@@ -34,7 +34,7 @@ fn test_map() {
   fn square(&int x) -> int { ret x * x; }
   let std::option::operator[int, int] op = square;
   let vec[int] v = [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 = [1, 2, 3, 4, 5];
   auto v1 = [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/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index a09d8dc4ab8..2a03471db4c 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/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index b742af7cd12..30a8e57d1b7 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -6,8 +6,8 @@
 use std;
 
 import std::option;
-import std::_uint;
-import std::_vec;
+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/str-append.rs b/src/test/run-pass/str-append.rs
index ed2e3a7a90d..7dc17cd652f 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 0fea6a69473..27050091554 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -1,10 +1,10 @@
 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/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 22a97ed7002..491f192ab4f 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::str;
+import std::vec;
 import std::io;
 
 fn main() {
   // Chars of 1, 2, 3, and 4 bytes
   let vec[char] chs = ['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([0x80_u8]));
-  assert (!_str::is_utf8([0xc0_u8]));
-  assert (!_str::is_utf8([0xc0_u8, 0x10_u8]));
+  assert (str::is_utf8(str::bytes(s)));
+  assert (!str::is_utf8([0x80_u8]));
+  assert (!str::is_utf8([0xc0_u8]));
+  assert (!str::is_utf8([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-append.rs b/src/test/run-pass/vec-append.rs
index 1d0d2509570..46b0cd6f2a1 100644
--- a/src/test/run-pass/vec-append.rs
+++ b/src/test/run-pass/vec-append.rs
@@ -4,8 +4,8 @@
 // -*- rust -*-
 
 use std;
-import std::_str;
-import std::_vec;
+import std::str;
+import std::vec;
 
 
 // FIXME: import std::dbg::const_refcount. Currently
@@ -53,30 +53,30 @@ fn slow_growth2_helper(str s) {   // ref up: s
     let vec[str] v = [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 cb26e4845d5..c46e4d5ee18 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 = [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);
 }