Finally rename std::_xxx to std::xxx

Except for _task, which is still a keyword.

9 files changed, 130 insertions, 130 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 5dfc2d8ddfa..2b5959028d4 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -1,7 +1,7 @@
 import std::map::hashmap;
 import std::option;
-import std::_str;
-import std::_vec;
+import std::str;
+import std::vec;
 import util::common::span;
 import util::common::spanned;
 import util::common::ty_mach;
@@ -454,7 +454,7 @@ fn is_exported(ident i, _mod m) -> bool {
     for (@ast::view_item vi in m.view_items) {
         alt (vi.node) {
             case (ast::view_item_export(?id)) {
-                if (_str::eq(i, id)) {
+                if (str::eq(i, id)) {
                     ret true;
                 }
                 count += 1;
diff --git a/src/comp/front/codemap.rs b/src/comp/front/codemap.rs
index cd959d9d88d..a9aacd8c6c2 100644
--- a/src/comp/front/codemap.rs
+++ b/src/comp/front/codemap.rs
@@ -1,4 +1,4 @@
-import std::_vec;
+import std::vec;
 
 /* A codemap is a thing that maps uints to file/line/column positions
  * in a crate. This to make it possible to represent the positions
@@ -24,18 +24,18 @@ fn new_filemap(str filename, uint start_pos) -> filemap {
 }
 
 fn next_line(filemap file, uint pos) {
-    _vec::push[uint](file.lines, pos);
+    vec::push[uint](file.lines, pos);
 }
 
 fn lookup_pos(codemap map, uint pos) -> loc {
-    auto a = 0u; auto b = _vec::len[filemap](map.files);
+    auto a = 0u; auto b = vec::len[filemap](map.files);
     while (b - a > 1u) {
         auto m = (a + b) / 2u;
         if (map.files.(m).start_pos > pos) { b = m; }
         else { a = m; }
     }
     auto f = map.files.(a);
-    a = 0u; b = _vec::len[uint](f.lines);
+    a = 0u; b = vec::len[uint](f.lines);
     while (b - a > 1u) {
         auto m = (a + b) / 2u;
         if (f.lines.(m) > pos) { b = m; }
diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs
index 3ac7b3638e1..7d61afc1de9 100644
--- a/src/comp/front/creader.rs
+++ b/src/comp/front/creader.rs
@@ -14,9 +14,9 @@ import back::x86;
 import util::common;
 import util::common::span;
 
-import std::_str;
-import std::_uint;
-import std::_vec;
+import std::str;
+import std::uint;
+import std::vec;
 import std::ebml;
 import std::fs;
 import std::io;
@@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
             while (peek(st) as char != ']') {
                 auto name = "";
                 while (peek(st) as char != '=') {
-                    name += _str::unsafe_from_byte(next(st));
+                    name += str::unsafe_from_byte(next(st));
                 }
                 st.pos = st.pos + 1u;
                 fields += [rec(ident=name, mt=parse_mt(st, sd))];
@@ -155,7 +155,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
                 }
                 auto name = "";
                 while (peek(st) as char != '[') {
-                    name += _str::unsafe_from_byte(next(st));
+                    name += str::unsafe_from_byte(next(st));
                 }
                 auto func = parse_ty_fn(st, sd);
                 methods += [rec(proto=proto,
@@ -205,7 +205,7 @@ fn parse_mt(@pstate st, str_def sd) -> ty::mt {
 fn parse_def(@pstate st, str_def sd) -> ast::def_id {
     auto def = "";
     while (peek(st) as char != '|') {
-        def += _str::unsafe_from_byte(next(st));
+        def += str::unsafe_from_byte(next(st));
     }
     st.pos = st.pos + 1u;
     ret sd(def);
@@ -260,7 +260,7 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) {
 
 fn parse_def_id(vec[u8] buf) -> ast::def_id {
     auto colon_idx = 0u;
-    auto len = _vec::len[u8](buf);
+    auto len = vec::len[u8](buf);
     while (colon_idx < len && buf.(colon_idx) != (':' as u8)) {
         colon_idx += 1u;
     }
@@ -269,10 +269,10 @@ fn parse_def_id(vec[u8] buf) -> ast::def_id {
         fail;
     }
 
-    auto crate_part = _vec::slice[u8](buf, 0u, colon_idx);
-    auto def_part = _vec::slice[u8](buf, colon_idx + 1u, len);
-    auto crate_num = _uint::parse_buf(crate_part, 10u) as int;
-    auto def_num = _uint::parse_buf(def_part, 10u) as int;
+    auto crate_part = vec::slice[u8](buf, 0u, colon_idx);
+    auto def_part = vec::slice[u8](buf, colon_idx + 1u, len);
+    auto crate_num = uint::parse_buf(crate_part, 10u) as int;
+    auto def_num = uint::parse_buf(def_part, 10u) as int;
     ret tup(crate_num, def_num);
 }
 
@@ -289,8 +289,8 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
     auto belt = metadata::tag_index_buckets_bucket_elt;
     for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
         auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
-        if (eq_fn(_vec::slice[u8](elt.data, elt.start+4u, elt.end))) {
-            _vec::push(result, ebml::doc_at(d.data, pos));
+        if (eq_fn(vec::slice[u8](elt.data, elt.start+4u, elt.end))) {
+            vec::push(result, ebml::doc_at(d.data, pos));
         }
     }
     ret result;
@@ -300,16 +300,16 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
 // definition the path refers to.
 fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] {
     fn eq_item(vec[u8] data, str s) -> bool {
-        ret _str::eq(_str::unsafe_from_bytes(data), s);
+        ret str::eq(str::unsafe_from_bytes(data), s);
     }
-    auto s = _str::connect(path, "::");
+    auto s = str::connect(path, "::");
     auto md = ebml::new_doc(data);
     auto paths = ebml::get_doc(md, metadata::tag_paths);
     auto eqer = bind eq_item(_, s);
     let vec[ast::def_id] result = [];
     for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) {
         auto did_doc = ebml::get_doc(doc, metadata::tag_def_id);
-        _vec::push(result, parse_def_id(ebml::doc_data(did_doc)));
+        vec::push(result, parse_def_id(ebml::doc_data(did_doc)));
     }
     ret result;
 }
@@ -320,7 +320,7 @@ fn maybe_find_item(int item_id, &ebml::doc items) -> option::t[ebml::doc] {
     }
     auto eqer = bind eq_item(_, item_id);
     auto found = lookup_hash(items, eqer, metadata::hash_def_num(item_id));
-    if (_vec::len(found) == 0u) {
+    if (vec::len(found) == 0u) {
         ret option::none[ebml::doc];
     } else {
         ret option::some[ebml::doc](found.(0));
@@ -345,7 +345,7 @@ fn item_kind(&ebml::doc item) -> u8 {
 
 fn item_symbol(&ebml::doc item) -> str {
     auto sym = ebml::get_doc(item, metadata::tag_items_data_item_symbol);
-    ret _str::unsafe_from_bytes(ebml::doc_data(sym));
+    ret str::unsafe_from_bytes(ebml::doc_data(sym));
 }
 
 fn variant_tag_id(&ebml::doc d) -> ast::def_id {
@@ -359,13 +359,13 @@ fn item_type(&ebml::doc item, int this_cnum, ty::ctxt tcx) -> ty::t {
         // that, in turn, links against another crate. We need a mapping
         // from crate ID to crate "meta" attributes as part of the crate
         // metadata:
-        auto buf = _str::bytes(s);
+        auto buf = str::bytes(s);
         auto external_def_id = parse_def_id(buf);
         ret tup(this_cnum, external_def_id._1);
     }
 
     auto tp = ebml::get_doc(item, metadata::tag_items_data_item_type);
-    auto s = _str::unsafe_from_bytes(ebml::doc_data(tp));
+    auto s = str::unsafe_from_bytes(ebml::doc_data(tp));
     ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
                       bind parse_external_def_id(this_cnum, _), tcx);
 }
@@ -384,25 +384,25 @@ fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
     auto v = metadata::tag_items_data_item_variant;
     for each (ebml::doc p in ebml::tagged_docs(item, v)) {
         auto ext = parse_def_id(ebml::doc_data(p));
-        _vec::push[ast::def_id](ids, tup(this_cnum, ext._1));
+        vec::push[ast::def_id](ids, tup(this_cnum, ext._1));
     }
     ret ids;
 }
 
 fn get_metadata_section(str filename) -> option::t[vec[u8]] {
     auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile
-        (_str::buf(filename));
+        (str::buf(filename));
     if (mb as int == 0) {ret option::none[vec[u8]];}
     auto of = mk_object_file(mb);
     auto si = mk_section_iter(of.llof);
     while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
         auto name_buf = llvm::LLVMGetSectionName(si.llsi);
-        auto name = _str::str_from_cstr(name_buf);
-        if (_str::eq(name, x86::get_meta_sect_name())) {
+        auto name = str::str_from_cstr(name_buf);
+        if (str::eq(name, x86::get_meta_sect_name())) {
             auto cbuf = llvm::LLVMGetSectionContents(si.llsi);
             auto csz = llvm::LLVMGetSectionSize(si.llsi);
-            auto cvbuf = cbuf as _vec::vbuf;
-            ret option::some[vec[u8]](_vec::vec_from_vbuf[u8](cvbuf, csz));
+            auto cvbuf = cbuf as vec::vbuf;
+            ret option::some[vec[u8]](vec::vec_from_vbuf[u8](cvbuf, csz));
         }
         llvm::LLVMMoveToNextSection(si.llsi);
     }
@@ -481,7 +481,7 @@ fn lookup_defs(session::session sess, int cnum, vec[ast::ident] path)
     -> vec[ast::def] {
     auto data = sess.get_external_crate(cnum).data;
 
-    ret _vec::map(bind lookup_def(cnum, data, _),
+    ret vec::map(bind lookup_def(cnum, data, _),
                   resolve_path(path, data));
 }
 
@@ -580,8 +580,8 @@ fn list_file_metadata(str path, io::writer out) {
 fn read_path(&ebml::doc d) -> tup(str, uint) {
     auto desc = ebml::doc_data(d);
     auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u);
-    auto pathbytes = _vec::slice[u8](desc, 4u, _vec::len[u8](desc));
-    auto path = _str::unsafe_from_bytes(pathbytes);
+    auto pathbytes = vec::slice[u8](desc, 4u, vec::len[u8](desc));
+    auto path = str::unsafe_from_bytes(pathbytes);
     ret tup(path, pos);
 }
 
diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index c44af3d0926..b66c6909e61 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -1,5 +1,5 @@
-import std::_vec;
-import std::_str;
+import std::vec;
+import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
@@ -92,7 +92,7 @@ fn val_as_str(val v) -> str {
 
 fn lookup(session::session sess, env e, span sp, ident i) -> val {
     for (tup(ident, val) pair in e) {
-        if (_str::eq(i, pair._0)) {
+        if (str::eq(i, pair._0)) {
             ret pair._1;
         }
     }
@@ -115,8 +115,8 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
 fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
     alt (x.node) {
         case (ast::expr_path(?pth, _)) {
-            if (_vec::len[ident](pth.node.idents) == 1u &&
-                _vec::len[@ast::ty](pth.node.types) == 0u) {
+            if (vec::len[ident](pth.node.idents) == 1u &&
+                vec::len[@ast::ty](pth.node.types) == 0u) {
                 ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
             }
             cx.sess.span_err(x.span, "evaluating structured path-name");
@@ -225,7 +225,7 @@ fn val_eq(session::session sess, span sp, val av, val bv) -> bool {
         ret val_as_int(av) == val_as_int(bv);
     }
     if (val_is_str(av) && val_is_str(bv)) {
-        ret _str::eq(val_as_str(av),
+        ret str::eq(val_as_str(av),
                     val_as_str(bv));
     }
     sess.span_err(sp, "bad types in comparison");
@@ -394,7 +394,7 @@ fn eval_crate_directive(ctx cx,
             cx.next_ann = p0.next_ann_num();
             auto im = ast::item_mod(id, m0, next_id);
             auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
-            _vec::push[@ast::item](items, i);
+            vec::push[@ast::item](items, i);
         }
 
         case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
@@ -411,11 +411,11 @@ fn eval_crate_directive(ctx cx,
             auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
             auto im = ast::item_mod(id, m0, cx.p.next_def_id());
             auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
-            _vec::push[@ast::item](items, i);
+            vec::push[@ast::item](items, i);
         }
 
         case (ast::cdir_view_item(?vi)) {
-            _vec::push[@ast::view_item](view_items, vi);
+            vec::push[@ast::view_item](view_items, vi);
         }
 
         case (ast::cdir_meta(?mi)) {
diff --git a/src/comp/front/extenv.rs b/src/comp/front/extenv.rs
index f9ac6a52085..f5d86dde3e7 100644
--- a/src/comp/front/extenv.rs
+++ b/src/comp/front/extenv.rs
@@ -6,8 +6,8 @@
 
 import util::common;
 
-import std::_str;
-import std::_vec;
+import std::str;
+import std::vec;
 import std::option;
 import std::generic_os;
 
@@ -19,7 +19,7 @@ fn expand_syntax_ext(parser::parser p,
                      vec[@ast::expr] args,
                      option::t[str] body) -> @ast::expr {
 
-    if (_vec::len[@ast::expr](args) != 1u) {
+    if (vec::len[@ast::expr](args) != 1u) {
         p.err("malformed #env call");
     }
 
diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs
index 9c15d11e4c4..8ef37b8536c 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/front/extfmt.rs
@@ -7,8 +7,8 @@
 import front::parser::parser;
 import util::common;
 
-import std::_str;
-import std::_vec;
+import std::str;
+import std::vec;
 import std::option;
 import std::option::none;
 import std::option::some;
@@ -50,7 +50,7 @@ fn expand_syntax_ext(parser p,
                      vec[@ast::expr] args,
                      option::t[str] body) -> @ast::expr {
 
-    if (_vec::len[@ast::expr](args) == 0u) {
+    if (vec::len[@ast::expr](args) == 0u) {
         // FIXME: Handle error correctly.
         log_err "malformed #fmt call";
         fail;
@@ -62,8 +62,8 @@ fn expand_syntax_ext(parser p,
     // log fmt;
 
     auto pieces = parse_fmt_string(fmt);
-    auto args_len = _vec::len[@ast::expr](args);
-    auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u);
+    auto args_len = vec::len[@ast::expr](args);
+    auto fmt_args = vec::slice[@ast::expr](args, 1u, args_len - 1u);
     ret pieces_to_expr(p, pieces, args);
 }
 
@@ -203,7 +203,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
             // FIXME: 0-length vectors can't have their type inferred
             // through the rec that these flags are a member of, so
             // this is a hack placeholder flag
-            if (_vec::len[@ast::expr](flagexprs) == 0u) {
+            if (vec::len[@ast::expr](flagexprs) == 0u) {
                 flagexprs += [make_rt_path_expr(p, sp, "flag_none")];
             }
 
@@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
     fn log_conv(conv c) {
         alt (c.param) {
             case (some[int](?p)) {
-                log "param: " + std::_int::to_str(p, 10u);
+                log "param: " + std::int::to_str(p, 10u);
             }
             case (_) {
                 log "param: none";
@@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
         }
         alt (c.width) {
             case (count_is(?i)) {
-                log "width: count is " + std::_int::to_str(i, 10u);
+                log "width: count is " + std::int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "width: count is param " + std::_int::to_str(i, 10u);
+                log "width: count is param " + std::int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "width: count is next param";
@@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
         }
         alt (c.precision) {
             case (count_is(?i)) {
-                log "prec: count is " + std::_int::to_str(i, 10u);
+                log "prec: count is " + std::int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "prec: count is param " + std::_int::to_str(i, 10u);
+                log "prec: count is param " + std::int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "prec: count is next param";
@@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
                 tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr);
             }
             case (piece_conv(?conv)) {
-                if (n >= _vec::len[@ast::expr](args)) {
+                if (n >= vec::len[@ast::expr](args)) {
                     log_err "too many conversions in #fmt string";
                     fail;
                 }
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index c151dc2f7be..d5e885c7bf0 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -1,7 +1,7 @@
 import std::io;
-import std::_str;
-import std::_vec;
-import std::_int;
+import std::str;
+import std::vec;
+import std::int;
 import std::map;
 import std::map::hashmap;
 import std::option;
@@ -54,13 +54,13 @@ fn new_reader(session sess, io::reader rdr,
         }
 
         fn next() -> char {
-            if (pos < len) {ret _str::char_at(file, pos);}
+            if (pos < len) {ret str::char_at(file, pos);}
             else {ret -1 as char;}
         }
 
         fn init() {
             if (pos < len) {
-                auto next = _str::char_range_at(file, pos);
+                auto next = str::char_range_at(file, pos);
                 pos = next._1;
                 ch = next._0;
             }
@@ -72,7 +72,7 @@ fn new_reader(session sess, io::reader rdr,
                 if (ch == '\n') {
                     codemap::next_line(fm, chpos);
                 }
-                auto next = _str::char_range_at(file, pos);
+                auto next = str::char_range_at(file, pos);
                 pos = next._1;
                 ch = next._0;
             } else {
@@ -90,9 +90,9 @@ fn new_reader(session sess, io::reader rdr,
             sess.span_err(rec(lo=chpos, hi=chpos), m);
         }
     }
-    auto file = _str::unsafe_from_bytes(rdr.read_whole_stream());
+    auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
     let vec[str] strs = [];
-    auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char,
+    auto rd = reader(sess, file, str::byte_len(file), 0u, -1 as char,
                      filemap.start_pos, filemap.start_pos,
                      strs, filemap, itr);
     rd.init();
@@ -228,15 +228,15 @@ fn scan_exponent(reader rdr) -> option::t[str] {
     auto res = "";
 
     if (c == 'e' || c == 'E') {
-        res += _str::from_bytes([c as u8]);
+        res += str::from_bytes([c as u8]);
         rdr.bump();
         c = rdr.curr();
         if (c == '-' || c == '+') {
-            res += _str::from_bytes([c as u8]);
+            res += str::from_bytes([c as u8]);
             rdr.bump();
         }
         auto exponent = scan_dec_digits(rdr);
-        if (_str::byte_len(exponent) > 0u) {
+        if (str::byte_len(exponent) > 0u) {
             ret(some(res + exponent));
         }
         else {
@@ -256,7 +256,7 @@ fn scan_dec_digits(reader rdr) -> str {
 
     while (is_dec_digit (c) || c == '_') {
         if (c != '_') {
-            res += _str::from_bytes([c as u8]);
+            res += str::from_bytes([c as u8]);
         }
         rdr.bump();
         c = rdr.curr();
@@ -458,12 +458,12 @@ fn next_token(reader rdr) -> token::token {
 
     if (is_alpha(c) || c == '_') {
         while (is_alnum(c) || c == '_') {
-            _str::push_char(accum_str, c);
+            str::push_char(accum_str, c);
             rdr.bump();
             c = rdr.curr();
         }
 
-        if (_str::eq(accum_str, "_")) {
+        if (str::eq(accum_str, "_")) {
             ret token::UNDERSCORE;
         }
 
@@ -621,37 +621,37 @@ fn next_token(reader rdr) -> token::token {
                         alt (rdr.next()) {
                             case ('n') {
                                 rdr.bump();
-                                _str::push_byte(accum_str, '\n' as u8);
+                                str::push_byte(accum_str, '\n' as u8);
                             }
                             case ('r') {
                                 rdr.bump();
-                                _str::push_byte(accum_str, '\r' as u8);
+                                str::push_byte(accum_str, '\r' as u8);
                             }
                             case ('t') {
                                 rdr.bump();
-                                _str::push_byte(accum_str, '\t' as u8);
+                                str::push_byte(accum_str, '\t' as u8);
                             }
                             case ('\\') {
                                 rdr.bump();
-                                _str::push_byte(accum_str, '\\' as u8);
+                                str::push_byte(accum_str, '\\' as u8);
                             }
                             case ('"') {
                                 rdr.bump();
-                                _str::push_byte(accum_str, '"' as u8);
+                                str::push_byte(accum_str, '"' as u8);
                             }
 
                             case ('x') {
-                                _str::push_char(accum_str,
+                                str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
                             case ('u') {
-                                _str::push_char(accum_str,
+                                str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
                             case ('U') {
-                                _str::push_char(accum_str,
+                                str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
@@ -663,7 +663,7 @@ fn next_token(reader rdr) -> token::token {
                         }
                     }
                     case (_) {
-                        _str::push_char(accum_str, rdr.curr());
+                        str::push_char(accum_str, rdr.curr());
                     }
                 }
                 rdr.bump();
@@ -754,7 +754,7 @@ fn read_line_comment(reader rdr) -> cmnt {
     while (rdr.curr() == ' ') {rdr.bump();}
     auto val = "";
     while (rdr.curr() != '\n' && !rdr.is_eof()) {
-        _str::push_char(val, rdr.curr());
+        str::push_char(val, rdr.curr());
         rdr.bump();
     }
     ret rec(val=cmnt_line(val),
@@ -771,7 +771,7 @@ fn read_block_comment(reader rdr) -> cmnt {
     auto level = 1;
     while (true) {
         if (rdr.curr() == '\n') {
-            _vec::push[str](lines, val);
+            vec::push[str](lines, val);
             val = "";
             consume_whitespace(rdr);
         } else {
@@ -779,13 +779,13 @@ fn read_block_comment(reader rdr) -> cmnt {
                 level -= 1;
                 if (level == 0) {
                     rdr.bump(); rdr.bump();
-                    _vec::push[str](lines, val);
+                    vec::push[str](lines, val);
                     break;
                 }
             } else if (rdr.curr() == '/' && rdr.next() == '*') {
                 level += 1;
             }
-            _str::push_char(val, rdr.curr());
+            str::push_char(val, rdr.curr());
             rdr.bump();
         }
         if (rdr.is_eof()) {
@@ -800,16 +800,16 @@ fn read_block_comment(reader rdr) -> cmnt {
 
 fn gather_comments(session sess, str path) -> vec[cmnt] {
     auto srdr = io::file_reader(path);
-    auto itr = @interner::mk_interner[str](_str::hash, _str::eq);
+    auto itr = @interner::mk_interner[str](str::hash, str::eq);
     auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
     let vec[cmnt] comments = [];
     while (!rdr.is_eof()) {
         while (true) {
             consume_whitespace(rdr);
             if (rdr.curr() == '/' && rdr.next() == '/') {
-                _vec::push[cmnt](comments, read_line_comment(rdr));
+                vec::push[cmnt](comments, read_line_comment(rdr));
             } else if (rdr.curr() == '/' && rdr.next() == '*') {
-                _vec::push[cmnt](comments, read_block_comment(rdr));
+                vec::push[cmnt](comments, read_block_comment(rdr));
             } else { break; }
         }
         next_token(rdr);
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index 34162a44f75..c4135814175 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1,6 +1,6 @@
 import std::io;
-import std::_vec;
-import std::_str;
+import std::vec;
+import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
@@ -156,13 +156,13 @@ fn new_parser(session::session sess,
             }
         }
     auto ftype = SOURCE_FILE;
-    if (_str::ends_with(path, ".rc")) {
+    if (str::ends_with(path, ".rc")) {
         ftype = CRATE_FILE;
     }
     auto srdr = io::file_reader(path);
     auto filemap = codemap::new_filemap(path, pos);
-    _vec::push[codemap::filemap](sess.get_codemap().files, filemap);
-    auto itr = @interner::mk_interner[str](_str::hash, _str::eq);
+    vec::push[codemap::filemap](sess.get_codemap().files, filemap);
+    auto itr = @interner::mk_interner[str](str::hash, str::eq);
     auto rdr = lexer::new_reader(sess, srdr, filemap, itr);
     // Make sure npos points at first actual token:
     lexer::consume_any_whitespace(rdr);
@@ -278,14 +278,14 @@ fn parse_str_lit_or_env_ident(parser p) -> ast::ident {
 
 fn is_word(&parser p, &str word) -> bool {
     ret alt (p.peek()) {
-        case (token::IDENT(?sid, false)) { _str::eq(word, p.get_str(sid)) }
+        case (token::IDENT(?sid, false)) { str::eq(word, p.get_str(sid)) }
         case (_) { false }
     };
 }
 fn eat_word(&parser p, &str word) -> bool {
     alt (p.peek()) {
         case (token::IDENT(?sid, false)) {
-            if (_str::eq(word, p.get_str(sid))) {
+            if (str::eq(word, p.get_str(sid))) {
                 p.bump();
                 ret true;
             } else { ret false; }
@@ -433,7 +433,7 @@ fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
         while (true) {
             auto constr = parse_ty_constr(p);
             hi = constr.span.hi;
-            _vec::push[@ast::constr](constrs, constr);
+            vec::push[@ast::constr](constrs, constr);
             if (p.peek() == token::COMMA) {
                 p.bump();
             } else {
@@ -818,7 +818,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
             if (eat_word(p, "with")) {
                 with_obj = some[ast::ident](parse_ident(p));
             } else {
-                _vec::push[@ast::method](meths,
+                vec::push[@ast::method](meths,
                                          parse_method(p));
             }
         }
@@ -1004,16 +1004,16 @@ fn expand_syntax_ext(parser p, ast::span sp,
                      &ast::path path, vec[@ast::expr] args,
                      option::t[str] body) -> ast::expr_ {
 
-    assert (_vec::len[ast::ident](path.node.idents) > 0u);
+    assert (vec::len[ast::ident](path.node.idents) > 0u);
     auto extname = path.node.idents.(0);
-    if (_str::eq(extname, "fmt")) {
+    if (str::eq(extname, "fmt")) {
         auto expanded = extfmt::expand_syntax_ext(p, args, body);
         auto newexpr = ast::expr_ext(path, args, body,
                                     expanded,
                                     p.get_ann());
 
         ret newexpr;
-    } else if (_str::eq(extname, "env")) {
+    } else if (str::eq(extname, "env")) {
         auto expanded = extenv::expand_syntax_ext(p, sp, args, body);
         auto newexpr = ast::expr_ext(path, args, body,
                                     expanded,
@@ -1833,7 +1833,7 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
         if (eat_word(p, "drop")) {
             dtor = some[@ast::method](parse_dtor(p));
         } else {
-            _vec::push[@ast::method](meths,
+            vec::push[@ast::method](meths,
                                      parse_method(p));
         }
     }
@@ -1953,12 +1953,12 @@ fn parse_item_native_mod(parser p) -> @ast::item {
     auto abi = ast::native_abi_cdecl;
     if (!is_word(p, "mod")) {
         auto t = parse_str_lit_or_env_ident(p);
-        if (_str::eq(t, "cdecl")) {
-        } else if (_str::eq(t, "rust")) {
+        if (str::eq(t, "cdecl")) {
+        } else if (str::eq(t, "rust")) {
             abi = ast::native_abi_rust;
-        } else if (_str::eq(t, "llvm")) {
+        } else if (str::eq(t, "llvm")) {
             abi = ast::native_abi_llvm;
-        } else if (_str::eq(t, "rust-intrinsic")) {
+        } else if (str::eq(t, "rust-intrinsic")) {
             abi = ast::native_abi_rust_intrinsic;
         } else {
             p.err("unsupported abi: " + t);
@@ -2079,16 +2079,16 @@ fn peeking_at_item(parser p) -> bool {
     alt (p.peek()) {
         case (token::IDENT(?sid, false)) {
             auto st = p.get_str(sid);
-            ret _str::eq(st, "state") ||
-                _str::eq(st, "gc") ||
-                _str::eq(st, "const") ||
-                _str::eq(st, "fn") ||
-                _str::eq(st, "pred") ||
-                _str::eq(st, "iter") ||
-                _str::eq(st, "mod") ||
-                _str::eq(st, "type") ||
-                _str::eq(st, "tag") ||
-                _str::eq(st, "obj");
+            ret str::eq(st, "state") ||
+                str::eq(st, "gc") ||
+                str::eq(st, "const") ||
+                str::eq(st, "fn") ||
+                str::eq(st, "pred") ||
+                str::eq(st, "iter") ||
+                str::eq(st, "mod") ||
+                str::eq(st, "type") ||
+                str::eq(st, "tag") ||
+                str::eq(st, "obj");
         }
         case (_) { ret false; }
     }
@@ -2193,7 +2193,7 @@ fn parse_rest_import_name(parser p, ast::ident first,
             defined_id = i;
         }
         case (_) {
-            auto len = _vec::len[ast::ident](identifiers);
+            auto len = vec::len[ast::ident](identifiers);
             defined_id = identifiers.(len - 1u);
         }
     }
@@ -2262,8 +2262,8 @@ fn is_view_item(&parser p) -> bool {
     alt (p.peek()) {
         case (token::IDENT(?sid, false)) {
             auto st = p.get_str(sid);
-            ret _str::eq(st, "use") || _str::eq(st, "import") ||
-                _str::eq(st, "export");
+            ret str::eq(st, "use") || str::eq(st, "import") ||
+                str::eq(st, "export");
         }
         case (_) { ret false; }
     }
@@ -2389,7 +2389,7 @@ fn parse_crate_directives(parser p, token::token term)
 
     while (p.peek() != term) {
         auto cdir = @parse_crate_directive(p);
-        _vec::push[@ast::crate_directive](cdirs, cdir);
+        vec::push[@ast::crate_directive](cdirs, cdir);
     }
 
     ret cdirs;
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index b72d41e7d24..41b8f30d628 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -2,9 +2,9 @@ import util::common::ty_mach;
 import util::common::ty_mach_to_str;
 import util::common::new_str_hash;
 import util::interner;
-import std::_int;
-import std::_uint;
-import std::_str;
+import std::int;
+import std::uint;
+import std::str;
 
 type str_num = uint;
 
@@ -133,10 +133,10 @@ fn to_str(lexer::reader r, token t) -> str {
         case (POUND) { ret "#"; }
 
         /* Literals */
-        case (LIT_INT(?i)) { ret _int::to_str(i, 10u); }
-        case (LIT_UINT(?u)) { ret _uint::to_str(u, 10u); }
+        case (LIT_INT(?i)) { ret int::to_str(i, 10u); }
+        case (LIT_UINT(?u)) { ret uint::to_str(u, 10u); }
         case (LIT_MACH_INT(?tm, ?i)) {
-            ret  _int::to_str(i, 10u)
+            ret  int::to_str(i, 10u)
                 + "_" + ty_mach_to_str(tm);
         }
         case (LIT_MACH_FLOAT(?tm, ?s)) {
@@ -152,8 +152,8 @@ fn to_str(lexer::reader r, token t) -> str {
         case (LIT_CHAR(?c)) {
             // FIXME: escape.
             auto tmp = "'";
-            _str::push_char(tmp, c);
-            _str::push_byte(tmp, '\'' as u8);
+            str::push_char(tmp, c);
+            str::push_byte(tmp, '\'' as u8);
             ret tmp;
         }
 
@@ -163,7 +163,7 @@ fn to_str(lexer::reader r, token t) -> str {
 
         /* Name components */
         case (IDENT(?s, _)) { ret interner::get[str](*r.get_interner(), s); }
-        case (IDX(?i)) { ret "_" + _int::to_str(i, 10u); }
+        case (IDX(?i)) { ret "_" + int::to_str(i, 10u); }
         case (UNDERSCORE) { ret "_"; }
 
         case (BRACEQUOTE(_)) { ret "<bracequote>"; }