Rename std::ivec to std::vec

16 files changed, 124 insertions, 126 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index ce20360e9ec..bed8ce31c4c 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -1,6 +1,5 @@
 // The Rust abstract syntax tree.
 
-import std::ivec;
 import std::option;
 import std::str;
 import codemap::span;
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 7e41865afa4..10bf7f478b7 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -1,4 +1,4 @@
-import std::ivec;
+import std::vec;
 import std::uint;
 import std::str;
 import std::term;
@@ -40,14 +40,14 @@ type lookup_fn = fn(file_pos) -> uint ;
 
 fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc {
     let a = 0u;
-    let b = ivec::len(map.files);
+    let b = vec::len(map.files);
     while b - a > 1u {
         let m = (a + b) / 2u;
         if lookup(map.files.(m).start_pos) > pos { b = m; } else { a = m; }
     }
     let f = map.files.(a);
     a = 0u;
-    b = ivec::len(f.lines);
+    b = vec::len(f.lines);
     while b - a > 1u {
         let m = (a + b) / 2u;
         if lookup(f.lines.(m)) > pos { b = m; } else { a = m; }
@@ -137,8 +137,8 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
         let max_lines = 6u;
         let elided = false;
         let display_lines = lines.lines;
-        if ivec::len(display_lines) > max_lines {
-            display_lines = ivec::slice(display_lines, 0u, max_lines);
+        if vec::len(display_lines) > max_lines {
+            display_lines = vec::slice(display_lines, 0u, max_lines);
             elided = true;
         }
         // Print the offending lines
@@ -149,7 +149,7 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
             io::stdout().write_str(s);
         }
         if elided {
-            let last_line = display_lines.(ivec::len(display_lines) - 1u);
+            let last_line = display_lines.(vec::len(display_lines) - 1u);
             let s = #fmt("%s:%u ", fm.name, last_line + 1u);
             let indent = str::char_len(s);
             let out = "";
@@ -160,7 +160,7 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
 
 
         // If there's one line at fault we can easily point to the problem
-        if ivec::len(lines.lines) == 1u {
+        if vec::len(lines.lines) == 1u {
             let lo = lookup_char_pos(cm, option::get(sp).lo);
             let digits = 0u;
             let num = lines.lines.(0) / 10u;
@@ -212,7 +212,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
 fn get_line(fm: filemap, line: int, file: &str) -> str {
     let begin: uint = fm.lines.(line).byte - fm.start_pos.byte;
     let end: uint;
-    if line as uint < ivec::len(fm.lines) - 1u {
+    if line as uint < vec::len(fm.lines) - 1u {
         end = fm.lines.(line + 1).byte - fm.start_pos.byte;
     } else {
         // If we're not done parsing the file, we're at the limit of what's
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index 9ad3d8d1b2e..47048ed1951 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -1,4 +1,4 @@
-import std::ivec;
+import std::vec;
 import std::option;
 import std::map::hashmap;
 import driver::session::session;
@@ -113,7 +113,7 @@ fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: str) -> str {
 fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
     alt expr.node {
       ast::expr_path(p) {
-        if ivec::len(p.node.types) > 0u || ivec::len(p.node.idents) != 1u {
+        if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
             cx.span_fatal(expr.span, error);
         } else { ret p.node.idents.(0); }
       }
diff --git a/src/comp/syntax/ext/concat_idents.rs b/src/comp/syntax/ext/concat_idents.rs
index 0106f76982b..f21af93668f 100644
--- a/src/comp/syntax/ext/concat_idents.rs
+++ b/src/comp/syntax/ext/concat_idents.rs
@@ -1,4 +1,3 @@
-import std::ivec;
 import std::option;
 import base::*;
 import syntax::ast;
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
index 2a897b570dd..5a53f26a007 100644
--- a/src/comp/syntax/ext/env.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -4,7 +4,7 @@
  * should all get sucked into either the compiler syntax extension plugin
  * interface.
  */
-import std::ivec;
+import std::vec;
 import std::option;
 import std::generic_os;
 import base::*;
@@ -16,7 +16,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#env requires arguments of the form `[...]`.") }
     };
-    if ivec::len[@ast::expr](args) != 1u {
+    if vec::len[@ast::expr](args) != 1u {
         cx.span_fatal(sp, "malformed #env call");
     }
     // FIXME: if this was more thorough it would manufacture an
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index 790e892cec2..d5e9fda2c84 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -4,7 +4,7 @@ import std::option::none;
 import std::option::some;
 
 import std::map::hashmap;
-import std::ivec;
+import std::vec;
 
 import syntax::ast::crate;
 import syntax::ast::expr_;
@@ -21,7 +21,7 @@ fn expand_expr(exts: &hashmap[str, syntax_extension], cx: &ext_ctxt,
           expr_mac(mac) {
             alt mac.node {
               mac_invoc(pth, args, body) {
-                assert (ivec::len(pth.node.idents) > 0u);
+                assert (vec::len(pth.node.idents) > 0u);
                 let extname = pth.node.idents.(0);
                 alt exts.find(extname) {
                   none. {
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 369fc7be0c3..b8ab57303df 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -5,7 +5,7 @@
  * should all get sucked into either the standard library extfmt module or the
  * compiler syntax extension plugin interface.
  */
-import std::ivec;
+import std::vec;
 import std::str;
 import std::option;
 import std::option::none;
@@ -21,7 +21,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.") }
     };
-    if ivec::len[@ast::expr](args) == 0u {
+    if vec::len[@ast::expr](args) == 0u {
         cx.span_fatal(sp, "#fmt requires a format string");
     }
     let fmt =
@@ -130,7 +130,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
             // through the rec that these flags are a member of, so
             // this is a hack placeholder flag
 
-            if ivec::len[@ast::expr](flagexprs) == 0u {
+            if vec::len[@ast::expr](flagexprs) == 0u {
                 flagexprs += ~[make_rt_path_expr(cx, sp, "flag_none")];
             }
             ret make_vec_expr(cx, sp, flagexprs);
@@ -307,7 +307,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
     let fmt_sp = args.(0).span;
     let n = 0u;
     let tmp_expr = make_new_str(cx, sp, "");
-    let nargs = ivec::len[@ast::expr](args);
+    let nargs = vec::len[@ast::expr](args);
     for pc: piece in pieces {
         alt pc {
           piece_string(s) {
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
index 9399f2e8fd4..c32acaf05b3 100644
--- a/src/comp/syntax/ext/ident_to_str.rs
+++ b/src/comp/syntax/ext/ident_to_str.rs
@@ -1,4 +1,4 @@
-import std::ivec;
+import std::vec;
 import std::option;
 import base::*;
 import syntax::ast;
@@ -9,7 +9,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#ident_to_str requires a vector argument .") }
     };
-    if ivec::len[@ast::expr](args) != 1u {
+    if vec::len[@ast::expr](args) != 1u {
         cx.span_fatal(sp, "malformed #ident_to_str call");
     }
 
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 543cd8b4644..29f474b7878 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -1,7 +1,7 @@
 use std;
 
 import codemap::span;
-import std::ivec;
+import std::vec;
 import std::option;
 import std::map::hashmap;
 import std::map::new_str_hash;
@@ -33,7 +33,7 @@ import ast::mac_invoc;
 export add_new_extension;
 
 fn path_to_ident(pth: &path) -> option::t[ident] {
-    if ivec::len(pth.node.idents) == 1u && ivec::len(pth.node.types) == 0u {
+    if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u {
         ret some(pth.node.idents.(0u));
     }
     ret none;
@@ -103,10 +103,10 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
                 if res != none {
                     cx.span_fatal(m.span, "only one ellipsis allowed");
                 }
-                res = some({pre: ivec::slice(elts, 0u, idx - 1u),
+                res = some({pre: vec::slice(elts, 0u, idx - 1u),
                             rep: some(elts.(idx - 1u)),
-                            post: ivec::slice(elts, idx + 1u,
-                                              ivec::len(elts))});
+                            post: vec::slice(elts, idx + 1u,
+                                              vec::len(elts))});
               }
               _ { }
             }
@@ -286,7 +286,7 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
     -> [@expr] {
     alt elts_to_ell(cx, exprs) {
       {pre: pre, rep: repeat_me_maybe, post: post} {
-        let res = ivec::map(recur, pre);
+        let res = vec::map(recur, pre);
         alt repeat_me_maybe {
           none. {}
           some(repeat_me) {
@@ -300,10 +300,10 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
                   seq(ms, _) {
                     alt repeat {
                       none. {
-                        repeat = some({rep_count: ivec::len(*ms), name: fv});
+                        repeat = some({rep_count: vec::len(*ms), name: fv});
                       }
                       some({rep_count: old_len, name: old_name}) {
-                        let len = ivec::len(*ms);
+                        let len = vec::len(*ms);
                         if old_len != len {
                             let msg = #fmt("'%s' occurs %u times, but ", fv,
                                            len) + #fmt("'%s' occurs %u times",
@@ -327,14 +327,14 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
                 while idx < rc {
                     *idx_path += ~[idx];
                     res += ~[recur(repeat_me)]; // whew!
-                    ivec::pop(*idx_path);
+                    vec::pop(*idx_path);
                     idx += 1u;
                 }
               }
             }
           }
         }
-        res += ivec::map(recur, post);
+        res += vec::map(recur, post);
         ret res;
       }
     }
@@ -356,7 +356,7 @@ fn transcribe_ident(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
 fn transcribe_path(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
                    p: &path_, fld: ast_fold) -> path_ {
     // Don't substitute into qualified names.
-    if ivec::len(p.types) > 0u || ivec::len(p.idents) != 1u { ret p; }
+    if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
     ret alt follow_for_trans(cx, b.find(p.idents.(0)), idx_path) {
           some(match_ident(id)) {
             {global: false, idents: ~[id.node], types: ~[]}
@@ -375,7 +375,7 @@ fn transcribe_expr(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
     ret alt e {
           expr_path(p) {
             // Don't substitute into qualified names.
-            if ivec::len(p.node.types) > 0u || ivec::len(p.node.idents) != 1u
+            if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u
                {
                 e
             }
@@ -452,14 +452,14 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
           expr_vec(p_elts, _, _) {
             alt elts_to_ell(cx, p_elts) {
               {pre: pre, rep: some(repeat_me), post: post} {
-                p_t_s_r_length(cx, ivec::len(pre) + ivec::len(post),
+                p_t_s_r_length(cx, vec::len(pre) + vec::len(post),
                                true, s, b);
-                if(ivec::len(pre) > 0u) {
+                if(vec::len(pre) > 0u) {
                     p_t_s_r_actual_vector(cx, pre, true, s, b);
                 }
-                p_t_s_r_ellipses(cx, repeat_me, ivec::len(pre), s, b);
+                p_t_s_r_ellipses(cx, repeat_me, vec::len(pre), s, b);
 
-                if(ivec::len(post) > 0u) {
+                if(vec::len(post) > 0u) {
                     cx.span_unimpl(e.span,
                                    "matching after `...` not yet supported");
                 }
@@ -468,7 +468,7 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
                 if post != ~[] {
                     cx.bug("elts_to_ell provided an invalid result");
                 }
-                p_t_s_r_length(cx, ivec::len(pre), false, s, b);
+                p_t_s_r_length(cx, vec::len(pre), false, s, b);
                 p_t_s_r_actual_vector(cx, pre, false, s, b);
               }
             }
@@ -534,7 +534,7 @@ fn p_t_s_r_path(cx: &ext_ctxt, p: &path, s: &selector, b: &binders) {
 }
 
 fn block_to_ident(blk: &blk_) -> option::t[ident] {
-    if ivec::len(blk.stmts) != 0u { ret none; }
+    if vec::len(blk.stmts) != 0u { ret none; }
     ret alt blk.expr {
           some(expr) {
             alt expr.node { expr_path(pth) { path_to_ident(pth) } _ { none } }
@@ -610,7 +610,7 @@ fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, offset: uint,
                   expr_vec(arg_elts, _, _) {
                     let elts = ~[];
                     let idx = offset;
-                    while idx < ivec::len(arg_elts) {
+                    while idx < vec::len(arg_elts) {
                         elts += ~[leaf(match_expr(arg_elts.(idx)))];
                         idx += 1u;
                     }
@@ -637,7 +637,7 @@ fn p_t_s_r_length(cx: &ext_ctxt, len: uint, at_least: bool, s: selector,
               match_expr(e) {
                 alt e.node {
                   expr_vec(arg_elts, _, _) {
-                    let actual_len = ivec::len(arg_elts);
+                    let actual_len = vec::len(arg_elts);
                     if (at_least && actual_len >= len) || actual_len == len {
                         some(leaf(match_exact))
                     } else { none }
@@ -655,7 +655,7 @@ fn p_t_s_r_length(cx: &ext_ctxt, len: uint, at_least: bool, s: selector,
 fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], repeat_after: bool,
                          s: &selector, b: &binders) {
     let idx: uint = 0u;
-    while idx < ivec::len(elts) {
+    while idx < vec::len(elts) {
         fn select(cx: &ext_ctxt, m: &matchable, idx: uint) -> match_result {
             ret alt m {
                   match_expr(e) {
@@ -689,7 +689,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
     for arg: @expr in args {
         alt arg.node {
           expr_vec(elts, mut, seq_kind) {
-            if ivec::len(elts) != 2u {
+            if vec::len(elts) != 2u {
                 cx.span_fatal((*arg).span,
                               "extension clause must consist of [" +
                                   "macro invocation, expansion body]");
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index 944915384ee..94dca5ef4cf 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -1,7 +1,7 @@
 import syntax::codemap::span;
 import ast::*;
 
-import std::ivec;
+import std::vec;
 import std::option;
 
 export ast_fold_precursor;
@@ -111,7 +111,7 @@ fn fold_meta_item_(mi: &@meta_item, fld: ast_fold) -> @meta_item {
                 meta_word(id) { meta_word(fld.fold_ident(id)) }
                 meta_list(id, mis) {
                   let fold_meta_item = bind fold_meta_item_(_, fld);
-                  meta_list(id, ivec::map(fold_meta_item, mis))
+                  meta_list(id, vec::map(fold_meta_item, mis))
                 }
                 meta_name_value(id, s) {
                   meta_name_value(fld.fold_ident(id), s)
@@ -154,10 +154,10 @@ fn noop_fold_crate(c: &crate_, fld: ast_fold) -> crate_ {
     let fold_meta_item = bind fold_meta_item_(_, fld);
     let fold_attribute = bind fold_attribute_(_, fold_meta_item);
 
-    ret {directives: ivec::map(fld.fold_crate_directive, c.directives),
+    ret {directives: vec::map(fld.fold_crate_directive, c.directives),
          module: fld.fold_mod(c.module),
-         attrs: ivec::map(fold_attribute, c.attrs),
-         config: ivec::map(fold_meta_item, c.config)};
+         attrs: vec::map(fold_attribute, c.attrs),
+         config: vec::map(fold_meta_item, c.config)};
 }
 
 fn noop_fold_crate_directive(cd: &crate_directive_, fld: ast_fold) ->
@@ -168,7 +168,7 @@ fn noop_fold_crate_directive(cd: &crate_directive_, fld: ast_fold) ->
           }
           cdir_dir_mod(id, fname, cds, attrs) {
             cdir_dir_mod(fld.fold_ident(id), fname,
-                         ivec::map(fld.fold_crate_directive, cds), attrs)
+                         vec::map(fld.fold_crate_directive, cds), attrs)
           }
           cdir_view_item(vi) { cdir_view_item(fld.fold_view_item(vi)) }
           cdir_syntax(_) { cd }
@@ -187,19 +187,19 @@ fn noop_fold_native_item(ni: &@native_item, fld: ast_fold) -> @native_item {
     let fold_attribute = bind fold_attribute_(_, fold_meta_item);
 
     ret @{ident: fld.fold_ident(ni.ident),
-          attrs: ivec::map(fold_attribute, ni.attrs),
+          attrs: vec::map(fold_attribute, ni.attrs),
           node:
               alt ni.node {
                 native_item_ty. { native_item_ty }
                 native_item_fn(st, fdec, typms) {
                   native_item_fn(st,
-                                 {inputs: ivec::map(fold_arg, fdec.inputs),
+                                 {inputs: vec::map(fold_arg, fdec.inputs),
                                   output: fld.fold_ty(fdec.output),
                                   purity: fdec.purity,
                                   il: fdec.il,
                                   cf: fdec.cf,
                                   constraints:
-                                      ivec::map(fld.fold_constr,
+                                      vec::map(fld.fold_constr,
                                                 fdec.constraints)}, typms)
                 }
               },
@@ -212,7 +212,7 @@ fn noop_fold_item(i: &@item, fld: ast_fold) -> @item {
     let fold_attribute = bind fold_attribute_(_, fold_meta_item);
 
     ret @{ident: fld.fold_ident(i.ident),
-          attrs: ivec::map(fold_attribute, i.attrs),
+          attrs: vec::map(fold_attribute, i.attrs),
           id: i.id,
           node: fld.fold_item_underscore(i.node),
           span: i.span};
@@ -234,11 +234,11 @@ fn noop_fold_item_underscore(i: &item_, fld: ast_fold) -> item_ {
           item_native_mod(nm) { item_native_mod(fld.fold_native_mod(nm)) }
           item_ty(t, typms) { item_ty(fld.fold_ty(t), typms) }
           item_tag(variants, typms) {
-            item_tag(ivec::map(fld.fold_variant, variants), typms)
+            item_tag(vec::map(fld.fold_variant, variants), typms)
           }
           item_obj(o, typms, d) {
-            item_obj({fields: ivec::map(fold_obj_field, o.fields),
-                      methods: ivec::map(fld.fold_method, o.methods)},
+            item_obj({fields: vec::map(fold_obj_field, o.fields),
+                      methods: vec::map(fld.fold_method, o.methods)},
                      typms, d)
           }
           item_res(dtor, did, typms, cid) {
@@ -253,7 +253,7 @@ fn noop_fold_method(m: &method_, fld: ast_fold) -> method_ {
 
 
 fn noop_fold_block(b: &blk_, fld: ast_fold) -> blk_ {
-    ret {stmts: ivec::map(fld.fold_stmt, b.stmts),
+    ret {stmts: vec::map(fld.fold_stmt, b.stmts),
          expr: option::map(fld.fold_expr, b.expr),
          id: b.id};
 }
@@ -269,7 +269,7 @@ fn noop_fold_stmt(s: &stmt_, fld: ast_fold) -> stmt_ {
 }
 
 fn noop_fold_arm(a: &arm, fld: ast_fold) -> arm {
-    ret {pats: ivec::map(fld.fold_pat, a.pats),
+    ret {pats: vec::map(fld.fold_pat, a.pats),
          body: fld.fold_block(a.body)};
 }
 
@@ -279,7 +279,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
           pat_bind(ident) { pat_bind(fld.fold_ident(ident)) }
           pat_lit(_) { p }
           pat_tag(pth, pats) {
-            pat_tag(fld.fold_path(pth), ivec::map(fld.fold_pat, pats))
+            pat_tag(fld.fold_path(pth), vec::map(fld.fold_pat, pats))
           }
           pat_rec(fields, etc) {
             let fs = ~[];
@@ -289,7 +289,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
             pat_rec(fs, etc)
           }
           pat_tup(elts) {
-            pat_tup(ivec::map(fld.fold_pat, elts))
+            pat_tup(vec::map(fld.fold_pat, elts))
           }
           pat_box(inner) { pat_box(fld.fold_pat(inner)) }
         };
@@ -297,7 +297,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
 
 fn noop_fold_decl(d: &decl_, fld: ast_fold) -> decl_ {
     ret alt d {
-          decl_local(ls) { decl_local(ivec::map(fld.fold_local, ls)) }
+          decl_local(ls) { decl_local(vec::map(fld.fold_local, ls)) }
           decl_item(it) { decl_item(fld.fold_item(it)) }
         }
 }
@@ -327,10 +327,10 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
                  alt ao.fields {
                    option::none. { ao.fields }
                    option::some(v) {
-                     option::some(ivec::map(fold_anon_obj_field, v))
+                     option::some(vec::map(fold_anon_obj_field, v))
                    }
                  },
-             methods: ivec::map(fld.fold_method, ao.methods),
+             methods: vec::map(fld.fold_method, ao.methods),
              inner_obj: option::map(fld.fold_expr, ao.inner_obj)}
     }
     let fold_anon_obj = bind fold_anon_obj_(_, fld);
@@ -343,11 +343,11 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
             expr_vec(fld.map_exprs(fld.fold_expr, exprs), mut, seq_kind)
           }
           expr_rec(fields, maybe_expr) {
-            expr_rec(ivec::map(fold_field, fields),
+            expr_rec(vec::map(fold_field, fields),
                      option::map(fld.fold_expr, maybe_expr))
           }
           expr_tup(elts) {
-            expr_tup(ivec::map(fld.fold_expr, elts))
+            expr_tup(vec::map(fld.fold_expr, elts))
           }
           expr_call(f, args) {
             expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args))
@@ -355,7 +355,7 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
           expr_self_method(id) { expr_self_method(fld.fold_ident(id)) }
           expr_bind(f, args) {
             let opt_map_se = bind option::map(fld.fold_expr, _);
-            expr_bind(fld.fold_expr(f), ivec::map(opt_map_se, args))
+            expr_bind(fld.fold_expr(f), vec::map(opt_map_se, args))
           }
           expr_spawn(spawn_dom, name, f, args) {
             expr_spawn(spawn_dom, name, fld.fold_expr(f),
@@ -390,7 +390,7 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
             expr_do_while(fld.fold_block(blk), fld.fold_expr(expr))
           }
           expr_alt(expr, arms) {
-            expr_alt(fld.fold_expr(expr), ivec::map(fld.fold_arm, arms))
+            expr_alt(fld.fold_expr(expr), vec::map(fld.fold_arm, arms))
           }
           expr_fn(f) { expr_fn(fld.fold_fn(f)) }
           expr_block(blk) { expr_block(fld.fold_block(blk)) }
@@ -459,27 +459,27 @@ fn noop_fold_fn(f: &_fn, fld: ast_fold) -> _fn {
     let fold_arg = bind fold_arg_(_, fld);
 
     ret {decl:
-             {inputs: ivec::map(fold_arg, f.decl.inputs),
+             {inputs: vec::map(fold_arg, f.decl.inputs),
               output: fld.fold_ty(f.decl.output),
               purity: f.decl.purity,
               il: f.decl.il,
               cf: f.decl.cf,
-              constraints: ivec::map(fld.fold_constr, f.decl.constraints)},
+              constraints: vec::map(fld.fold_constr, f.decl.constraints)},
          proto: f.proto,
          body: fld.fold_block(f.body)};
 }
 
 // ...nor do modules
 fn noop_fold_mod(m: &_mod, fld: ast_fold) -> _mod {
-    ret {view_items: ivec::map(fld.fold_view_item, m.view_items),
-         items: ivec::map(fld.fold_item, m.items)};
+    ret {view_items: vec::map(fld.fold_view_item, m.view_items),
+         items: vec::map(fld.fold_item, m.items)};
 }
 
 fn noop_fold_native_mod(nm: &native_mod, fld: ast_fold) -> native_mod {
     ret {native_name: nm.native_name,
          abi: nm.abi,
-         view_items: ivec::map(fld.fold_view_item, nm.view_items),
-         items: ivec::map(fld.fold_native_item, nm.items)}
+         view_items: vec::map(fld.fold_view_item, nm.view_items),
+         items: vec::map(fld.fold_native_item, nm.items)}
 }
 
 fn noop_fold_variant(v: &variant_, fld: ast_fold) -> variant_ {
@@ -487,15 +487,15 @@ fn noop_fold_variant(v: &variant_, fld: ast_fold) -> variant_ {
         ret {ty: fld.fold_ty(va.ty), id: va.id};
     }
     let fold_variant_arg = bind fold_variant_arg_(_, fld);
-    ret {name: v.name, args: ivec::map(fold_variant_arg, v.args), id: v.id};
+    ret {name: v.name, args: vec::map(fold_variant_arg, v.args), id: v.id};
 }
 
 fn noop_fold_ident(i: &ident, fld: ast_fold) -> ident { ret i; }
 
 fn noop_fold_path(p: &path_, fld: ast_fold) -> path_ {
     ret {global: p.global,
-         idents: ivec::map(fld.fold_ident, p.idents),
-         types: ivec::map(fld.fold_ty, p.types)};
+         idents: vec::map(fld.fold_ident, p.idents),
+         types: vec::map(fld.fold_ty, p.types)};
 }
 
 fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
@@ -514,7 +514,7 @@ fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
 /* temporarily eta-expand because of a compiler bug with using `fn[T]` as a
    value */
 fn noop_map_exprs(f: fn(&@expr) -> @expr , es: [@expr]) -> [@expr] {
-    ret ivec::map(f, es);
+    ret vec::map(f, es);
 }
 
 fn noop_id(i: node_id) -> node_id { ret i; }
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index edeb6df407b..8b7eaee1534 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -1,7 +1,7 @@
 
 import std::io;
 import std::int;
-import std::ivec;
+import std::vec;
 import std::str;
 import std::map;
 import std::map::hashmap;
@@ -669,7 +669,7 @@ fn read_block_comment(rdr: &reader, code_to_the_left: bool) -> cmnt {
     }
     let style = if code_to_the_left { trailing } else { isolated };
     consume_non_eol_whitespace(rdr);
-    if !rdr.is_eof() && rdr.curr() != '\n' && ivec::len(lines) == 1u {
+    if !rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u {
         style = mixed;
     }
     log "<<< block comment";
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 4569fe7d485..2d61f6b214a 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1,6 +1,6 @@
 
 import std::io;
-import std::ivec;
+import std::vec;
 import std::str;
 import std::option;
 import std::option::some;
@@ -87,18 +87,18 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
         fn peek() -> token::token { ret tok; }
         fn bump() {
             last_tok_span = tok_span;
-            if ivec::len(buffer) == 0u {
+            if vec::len(buffer) == 0u {
                 let next = lexer::next_token(rdr);
                 tok = next.tok;
                 tok_span = ast::mk_sp(next.chpos, rdr.get_chpos());
             } else {
-                let next = ivec::pop(buffer);
+                let next = vec::pop(buffer);
                 tok = next.tok;
                 tok_span = next.span;
             }
         }
         fn look_ahead(distance: uint) -> token::token {
-            while ivec::len(buffer) < distance {
+            while vec::len(buffer) < distance {
                 let next = lexer::next_token(rdr);
                 let sp = ast::mk_sp(next.chpos, rdr.get_chpos());
                 buffer = ~[{tok: next.tok, span: sp}] + buffer;
@@ -523,7 +523,7 @@ fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
                 p.bump();
                 ts += ~[parse_ty(p, false)];
             }
-            if ivec::len(ts) == 1u {
+            if vec::len(ts) == 1u {
                 t = ts.(0).node;
             } else {
                 t = ast::ty_tup(ts);
@@ -791,7 +791,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
         }
         hi = p.get_hi_pos();
         expect(p, token::RPAREN);
-        if ivec::len(es) == 1u {
+        if vec::len(es) == 1u {
             ret mk_expr(p, lo, hi, es.(0).node);
         } else {
             ret mk_expr(p, lo, hi, ast::expr_tup(es));
@@ -1023,7 +1023,7 @@ fn parse_syntax_ext(p: &parser) -> @ast::expr {
 
 fn parse_syntax_ext_naked(p: &parser, lo: uint) -> @ast::expr {
     let pth = parse_path(p);
-    if ivec::len(pth.node.idents) == 0u {
+    if vec::len(pth.node.idents) == 0u {
         p.fatal("expected a syntax expander name");
     }
     //temporary for a backwards-compatible cycle:
@@ -1474,7 +1474,7 @@ fn parse_pat(p: &parser) -> @ast::pat {
                 p.bump();
                 fields += ~[parse_pat(p)];
             }
-            if ivec::len(fields) == 1u { expect(p, token::COMMA); }
+            if vec::len(fields) == 1u { expect(p, token::COMMA); }
             hi = p.get_hi_pos();
             expect(p, token::RPAREN);
             pat = ast::pat_tup(fields);
@@ -1570,7 +1570,7 @@ fn parse_source_stmt(p: &parser) -> @ast::stmt {
         let maybe_item = parse_item(p, item_attrs);
 
         // If we have attributes then we should have an item
-        if ivec::len(item_attrs) > 0u {
+        if vec::len(item_attrs) > 0u {
             alt maybe_item {
               some(_) {/* fallthrough */ }
               _ { ret p.fatal("expected item"); }
@@ -1899,7 +1899,7 @@ fn parse_mod_items(p: &parser, term: token::token,
                    first_item_attrs: &[ast::attribute]) -> ast::_mod {
     // Shouldn't be any view items since we've already parsed an item attr
     let view_items =
-        if ivec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
+        if vec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
     let items: [@ast::item] = ~[];
     let initial_attrs = first_item_attrs;
     while p.peek() != term {
@@ -1982,7 +1982,7 @@ fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
     -> ast::native_mod {
     // Shouldn't be any view items since we've already parsed an item attr
     let view_items =
-        if ivec::len(first_item_attrs) == 0u {
+        if vec::len(first_item_attrs) == 0u {
             parse_native_view(p)
         } else { ~[] };
     let items: [@ast::native_item] = ~[];
@@ -2287,7 +2287,7 @@ fn parse_rest_import_name(p: &parser, first: ast::ident,
         if glob {
             ret ast::view_item_import_glob(identifiers, p.get_id());
         } else {
-            let len = ivec::len(identifiers);
+            let len = vec::len(identifiers);
             ret ast::view_item_import(identifiers.(len - 1u), identifiers,
                                       p.get_id());
         }
@@ -2412,7 +2412,7 @@ fn parse_crate_directive(p: &parser, first_outer_attr: &[ast::attribute]) ->
     // Collect the next attributes
     let outer_attrs = first_outer_attr + parse_outer_attributes(p);
     // In a crate file outer attributes are only going to apply to mods
-    let expect_mod = ivec::len(outer_attrs) > 0u;
+    let expect_mod = vec::len(outer_attrs) > 0u;
 
     let lo = p.get_lo_pos();
     if expect_mod || is_word(p, "mod") {
@@ -2467,7 +2467,7 @@ fn parse_crate_directives(p: &parser, term: token::token,
     // This is pretty ugly. If we have an outer attribute then we can't accept
     // seeing the terminator next, so if we do see it then fail the same way
     // parse_crate_directive would
-    if ivec::len(first_outer_attr) > 0u && p.peek() == term {
+    if vec::len(first_outer_attr) > 0u && p.peek() == term {
         expect_word(p, "mod");
     }
 
diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index 98770cf0e46..bd67c552cbb 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -1,6 +1,6 @@
 
 import std::io;
-import std::ivec;
+import std::vec;
 import std::str;
 
 
@@ -76,8 +76,8 @@ fn tok_str(t: token) -> str {
 
 fn buf_str(toks: &[mutable token], szs: &[mutable int], left: uint,
            right: uint, lim: uint) -> str {
-    let n = ivec::len(toks);
-    assert (n == ivec::len(szs));
+    let n = vec::len(toks);
+    assert (n == vec::len(szs));
     let i = left;
     let L = lim;
     let s = "[";
@@ -104,9 +104,9 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
 
     let n: uint = 3u * linewidth;
     log #fmt("mk_printer %u", linewidth);
-    let token: [mutable token] = ivec::init_elt_mut(EOF, n);
-    let size: [mutable int] = ivec::init_elt_mut(0, n);
-    let scan_stack: [mutable uint] = ivec::init_elt_mut(0u, n);
+    let token: [mutable token] = vec::init_elt_mut(EOF, n);
+    let size: [mutable int] = vec::init_elt_mut(0, n);
+    let scan_stack: [mutable uint] = vec::init_elt_mut(0u, n);
     let print_stack: [print_stack_elt] = ~[];
     ret printer(out, n, linewidth as int, // margin
                 linewidth as int, // space
@@ -403,7 +403,7 @@ obj printer(out: io::writer,
         pending_indentation += amount;
     }
     fn top() -> print_stack_elt {
-        let n = ivec::len(print_stack);
+        let n = vec::len(print_stack);
         let top: print_stack_elt = {offset: 0, pbreak: broken(inconsistent)};
         if n != 0u { top = print_stack.(n - 1u); }
         ret top;
@@ -432,8 +432,8 @@ obj printer(out: io::writer,
           }
           END. {
             log "print END -> pop END";
-            assert (ivec::len(print_stack) != 0u);
-            ivec::pop(print_stack);
+            assert (vec::len(print_stack) != 0u);
+            vec::pop(print_stack);
           }
           BREAK(b) {
             let top = self.top();
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index e0389c47874..437b9652261 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -1,5 +1,5 @@
 
-import std::ivec;
+import std::vec;
 import std::int;
 import std::io;
 import std::str;
@@ -50,7 +50,7 @@ type ps =
 
 fn ibox(s: &ps, u: uint) { s.boxes += ~[pp::inconsistent]; pp::ibox(s.s, u); }
 
-fn end(s: &ps) { ivec::pop(s.boxes); pp::end(s.s); }
+fn end(s: &ps) { vec::pop(s.boxes); pp::end(s.s); }
 
 fn rust_printer(writer: io::writer) -> ps {
     let boxes: [pp::breaks] = ~[];
@@ -229,7 +229,7 @@ fn commasep[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ) {
 fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ,
                      get_span: fn(&IN) -> codemap::span ) {
     box(s, 0u, b);
-    let len = ivec::len[IN](elts);
+    let len = vec::len[IN](elts);
     let i = 0u;
     for elt: IN in elts {
         maybe_print_comment(s, get_span(elt).hi);
@@ -454,9 +454,9 @@ fn print_item(s: &ps, item: &@ast::item) {
       }
       ast::item_tag(variants, params) {
         let newtype =
-            ivec::len(variants) == 1u &&
+            vec::len(variants) == 1u &&
                 str::eq(item.ident, variants.(0).node.name) &&
-                ivec::len(variants.(0).node.args) == 1u;
+                vec::len(variants.(0).node.args) == 1u;
         if newtype {
             ibox(s, indent_unit);
             word_space(s, "tag");
@@ -475,7 +475,7 @@ fn print_item(s: &ps, item: &@ast::item) {
                 space(s.s);
                 maybe_print_comment(s, v.span.lo);
                 word(s.s, v.node.name);
-                if ivec::len(v.node.args) > 0u {
+                if vec::len(v.node.args) > 0u {
                     popen(s);
                     fn print_variant_arg(s: &ps, arg: &ast::variant_arg) {
                         print_type(s, arg.ty);
@@ -725,7 +725,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         }
         if mut == ast::mut {
             word(s.s, "mutable");
-            if ivec::len(exprs) > 0u { nbsp(s); }
+            if vec::len(exprs) > 0u { nbsp(s); }
         }
         commasep_exprs(s, inconsistent, exprs);
         word(s.s, "]");
@@ -745,7 +745,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         commasep_cmnt(s, consistent, fields, print_field, get_span);
         alt wth {
           some(expr) {
-            if ivec::len(fields) > 0u { space(s.s); }
+            if vec::len(fields) > 0u { space(s.s); }
             ibox(s, indent_unit);
             word_space(s, "with");
             print_expr(s, expr);
@@ -1130,7 +1130,7 @@ fn print_path(s: &ps, path: &ast::path) {
         if first { first = false; } else { word(s.s, "::"); }
         word(s.s, id);
     }
-    if ivec::len(path.node.types) > 0u {
+    if vec::len(path.node.types) > 0u {
         word(s.s, "[");
         commasep(s, inconsistent, path.node.types, print_type);
         word(s.s, "]");
@@ -1147,7 +1147,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
       ast::pat_lit(lit) { print_literal(s, lit); }
       ast::pat_tag(path, args) {
         print_path(s, path);
-        if ivec::len(args) > 0u {
+        if vec::len(args) > 0u {
             popen(s);
             commasep(s, inconsistent, args, print_pat);
             pclose(s);
@@ -1165,7 +1165,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
         fn get_span(f: &ast::field_pat) -> codemap::span { ret f.pat.span; }
         commasep_cmnt(s, consistent, fields, print_field, get_span);
         if etc {
-            if ivec::len(fields) != 0u { word_space(s, ","); }
+            if vec::len(fields) != 0u { word_space(s, ","); }
             word(s.s, "_");
         }
         word(s.s, "}");
@@ -1243,7 +1243,7 @@ fn print_kind(s: &ps, kind: ast::kind) {
 }
 
 fn print_type_params(s: &ps, params: &[ast::ty_param]) {
-    if ivec::len(params) > 0u {
+    if vec::len(params) > 0u {
         word(s.s, "[");
         fn printParam(s: &ps, param: &ast::ty_param) {
             print_kind(s, param.kind);
@@ -1280,7 +1280,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
       ast::view_item_use(id, mta, _) {
         head(s, "use");
         word(s.s, id);
-        if ivec::len(mta) > 0u {
+        if vec::len(mta) > 0u {
             popen(s);
             commasep(s, consistent, mta, print_meta_item);
             pclose(s);
@@ -1288,7 +1288,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
       }
       ast::view_item_import(id, ids, _) {
         head(s, "import");
-        if !str::eq(id, ids.(ivec::len(ids) - 1u)) {
+        if !str::eq(id, ids.(vec::len(ids) - 1u)) {
             word_space(s, id);
             word_space(s, "=");
         }
@@ -1419,7 +1419,7 @@ fn print_remaining_comments(s: &ps) {
 }
 
 fn in_cbox(s: &ps) -> bool {
-    let len = ivec::len(s.boxes);
+    let len = vec::len(s.boxes);
     if len == 0u { ret false; }
     ret s.boxes.(len - 1u) == pp::consistent;
 }
@@ -1465,7 +1465,7 @@ fn lit_to_str(l: &@ast::lit) -> str { be to_str(l, print_literal); }
 fn next_lit(s: &ps) -> option::t[lexer::lit] {
     alt s.literals {
       some(lits) {
-        if s.cur_lit < ivec::len(lits) {
+        if s.cur_lit < vec::len(lits) {
             ret some(lits.(s.cur_lit));
         } else { ret none[lexer::lit]; }
       }
@@ -1490,7 +1490,7 @@ fn maybe_print_comment(s: &ps, pos: uint) {
 fn print_comment(s: &ps, cmnt: lexer::cmnt) {
     alt cmnt.style {
       lexer::mixed. {
-        assert (ivec::len(cmnt.lines) == 1u);
+        assert (vec::len(cmnt.lines) == 1u);
         zerobreak(s.s);
         word(s.s, cmnt.lines.(0));
         zerobreak(s.s);
@@ -1501,7 +1501,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
       }
       lexer::trailing. {
         word(s.s, " ");
-        if ivec::len(cmnt.lines) == 1u {
+        if vec::len(cmnt.lines) == 1u {
             word(s.s, cmnt.lines.(0));
             hardbreak(s.s);
         } else {
@@ -1557,7 +1557,7 @@ fn to_str[T](t: &T, f: fn(&ps, &T) ) -> str {
 fn next_comment(s: &ps) -> option::t[lexer::cmnt] {
     alt s.comments {
       some(cmnts) {
-        if s.cur_cmnt < ivec::len(cmnts) {
+        if s.cur_cmnt < vec::len(cmnts) {
             ret some(cmnts.(s.cur_cmnt));
         } else { ret none[lexer::cmnt]; }
       }
diff --git a/src/comp/syntax/untyped_ast.rs b/src/comp/syntax/untyped_ast.rs
index 4ae7ef38f8d..39982ec4ca4 100644
--- a/src/comp/syntax/untyped_ast.rs
+++ b/src/comp/syntax/untyped_ast.rs
@@ -1,5 +1,5 @@
 import std::ivec;
-import std::ivec::map;
+import std::vec::map;
 import std::option;
 import std::option::some;
 import std::option::none;
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
index 7f95d0ef0e7..3dbda76f5d9 100644
--- a/src/comp/syntax/util/interner.rs
+++ b/src/comp/syntax/util/interner.rs
@@ -1,7 +1,7 @@
 // An "interner" is a data structure that associates values with uint tags and
 // allows bidirectional lookup; i.e. given a value, one can easily find the
 // type, and vice versa.
-import std::ivec;
+import std::vec;
 import std::map;
 import std::map::hashmap;
 import std::map::hashfn;
@@ -25,7 +25,7 @@ fn intern[@T](itr: &interner[T], val: &T) -> uint {
     alt itr.map.find(val) {
       some(idx) { ret idx; }
       none. {
-        let new_idx = ivec::len[T](itr.vect);
+        let new_idx = vec::len[T](itr.vect);
         itr.map.insert(val, new_idx);
         itr.vect += ~[val];
         ret new_idx;
@@ -35,5 +35,5 @@ fn intern[@T](itr: &interner[T], val: &T) -> uint {
 
 fn get[T](itr: &interner[T], idx: uint) -> T { ret itr.vect.(idx); }
 
-fn len[T](itr : &interner[T]) -> uint { ret ivec::len(itr.vect); }
+fn len[T](itr : &interner[T]) -> uint { ret vec::len(itr.vect); }