rustc: Remove a bunch of exterior vectors

18 files changed, 302 insertions, 331 deletions

diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index 2586fb9ba92..aa0f71ff8e2 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -7,7 +7,7 @@ import middle::ty;
 import metadata::encoder;
 import std::str;
 import std::fs;
-import std::vec;
+import std::ivec;
 import std::option;
 import option::some;
 import option::none;
@@ -360,10 +360,14 @@ fn build_link_meta(&session::session sess, &ast::crate c,
             case (some(?v)) { v }
             case (none) {
                 auto name = {
-                    auto os = str::split(fs::basename(output), '.' as u8);
-                    assert (vec::len(os) >= 2u);
-                    vec::pop(os);
-                    str::connect(os, ".")
+                    auto os_vec = str::split(fs::basename(output), '.' as u8);
+                    // FIXME: Remove this vec->ivec conversion.
+                    auto os = ~[];
+                    for (str s in os_vec) { os += ~[s]; }
+
+                    assert (ivec::len(os) >= 2u);
+                    ivec::pop(os);
+                    str::connect_ivec(os, ".")
                 };
                 warn_missing(sess, "name", name);
                 name
diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs
index 6d95b25b95b..400ed3beab8 100644
--- a/src/comp/back/upcall.rs
+++ b/src/comp/back/upcall.rs
@@ -64,7 +64,7 @@ fn declare_upcalls(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type,
                    ModuleRef llmod)
    -> @upcalls {
     fn decl(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type,
-            ModuleRef llmod, str name, vec[TypeRef] tys,
+            ModuleRef llmod, str name, TypeRef[] tys,
             TypeRef rv) -> ValueRef {
         let TypeRef[] arg_tys = ~[taskptr_type];
         for (TypeRef t in tys) { arg_tys += ~[t]; }
@@ -76,62 +76,62 @@ fn declare_upcalls(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type,
     // FIXME: Sigh:.. remove this when I fix the typechecker pushdown.
     // --pcwalton
 
-    let vec[TypeRef] empty_vec = [];
-    ret @rec(grow_task=dv("grow_task", [T_size_t()]),
-             log_int=dv("log_int", [T_i32(), T_i32()]),
-             log_float=dv("log_float", [T_i32(), T_f32()]),
-             log_double=dv("log_double", [T_i32(), T_ptr(T_f64())]),
-             log_str=dv("log_str", [T_i32(), T_ptr(T_str())]),
-             trace_word=dv("trace_word", [T_int()]),
-             trace_str=dv("trace_str", [T_ptr(T_i8())]),
-             new_port=d("new_port", [T_size_t()], T_opaque_port_ptr()),
-             del_port=dv("del_port", [T_opaque_port_ptr()]),
-             new_chan=d("new_chan", [T_opaque_port_ptr()],
+    let TypeRef[] empty_vec = ~[];
+    ret @rec(grow_task=dv("grow_task", ~[T_size_t()]),
+             log_int=dv("log_int", ~[T_i32(), T_i32()]),
+             log_float=dv("log_float", ~[T_i32(), T_f32()]),
+             log_double=dv("log_double", ~[T_i32(), T_ptr(T_f64())]),
+             log_str=dv("log_str", ~[T_i32(), T_ptr(T_str())]),
+             trace_word=dv("trace_word", ~[T_int()]),
+             trace_str=dv("trace_str", ~[T_ptr(T_i8())]),
+             new_port=d("new_port", ~[T_size_t()], T_opaque_port_ptr()),
+             del_port=dv("del_port", ~[T_opaque_port_ptr()]),
+             new_chan=d("new_chan", ~[T_opaque_port_ptr()],
                         T_opaque_chan_ptr()),
-             flush_chan=dv("flush_chan", [T_opaque_chan_ptr()]),
-             del_chan=dv("del_chan", [T_opaque_chan_ptr()]),
-             clone_chan=d("clone_chan", [taskptr_type, T_opaque_chan_ptr()],
+             flush_chan=dv("flush_chan", ~[T_opaque_chan_ptr()]),
+             del_chan=dv("del_chan", ~[T_opaque_chan_ptr()]),
+             clone_chan=d("clone_chan", ~[taskptr_type, T_opaque_chan_ptr()],
                           T_opaque_chan_ptr()),
              _yield=dv("yield", empty_vec),
-             sleep=dv("sleep", [T_size_t()]),
-             send=dv("send", [T_opaque_chan_ptr(), T_ptr(T_i8())]),
-             recv=dv("recv", [T_ptr(T_ptr(T_i8())), T_opaque_port_ptr()]),
-             _fail=dv("fail", [T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]),
-             kill=dv("kill", [taskptr_type]),
+             sleep=dv("sleep", ~[T_size_t()]),
+             send=dv("send", ~[T_opaque_chan_ptr(), T_ptr(T_i8())]),
+             recv=dv("recv", ~[T_ptr(T_ptr(T_i8())), T_opaque_port_ptr()]),
+             _fail=dv("fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]),
+             kill=dv("kill", ~[taskptr_type]),
              exit=dv("exit", empty_vec),
-             malloc=d("malloc", [T_size_t(), T_ptr(tydesc_type)],
+             malloc=d("malloc", ~[T_size_t(), T_ptr(tydesc_type)],
                       T_ptr(T_i8())),
-             free=dv("free", [T_ptr(T_i8()), T_int()]),
+             free=dv("free", ~[T_ptr(T_i8()), T_int()]),
              shared_malloc=d("shared_malloc",
-                      [T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())),
-             shared_free=dv("shared_free", [T_ptr(T_i8())]),
-             mark=d("mark", [T_ptr(T_i8())], T_int()),
-             new_str=d("new_str", [T_ptr(T_i8()), T_size_t()],
+                      ~[T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())),
+             shared_free=dv("shared_free", ~[T_ptr(T_i8())]),
+             mark=d("mark", ~[T_ptr(T_i8())], T_int()),
+             new_str=d("new_str", ~[T_ptr(T_i8()), T_size_t()],
                        T_ptr(T_str())),
-                     dup_str=d("dup_str", [taskptr_type, T_ptr(T_str())],
+                     dup_str=d("dup_str", ~[taskptr_type, T_ptr(T_str())],
                        T_ptr(T_str())),
-             new_vec=d("new_vec", [T_size_t(), T_ptr(tydesc_type)],
+             new_vec=d("new_vec", ~[T_size_t(), T_ptr(tydesc_type)],
                        T_opaque_vec_ptr()),
              vec_append=d("vec_append",
-                          [T_ptr(tydesc_type), T_ptr(tydesc_type),
-                           T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(),
-                           T_bool()], T_void()),
+                          ~[T_ptr(tydesc_type), T_ptr(tydesc_type),
+                            T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(),
+                            T_bool()], T_void()),
              get_type_desc=d("get_type_desc",
-                             [T_ptr(T_nil()), T_size_t(), T_size_t(),
-                              T_size_t(), T_ptr(T_ptr(tydesc_type))],
+                             ~[T_ptr(T_nil()), T_size_t(), T_size_t(),
+                               T_size_t(), T_ptr(T_ptr(tydesc_type))],
                              T_ptr(tydesc_type)),
-             new_task=d("new_task", [T_ptr(T_str())], taskptr_type),
+             new_task=d("new_task", ~[T_ptr(T_str())], taskptr_type),
              start_task=d("start_task",
-                          [taskptr_type, T_int(), T_int(), T_size_t()],
-                          taskptr_type),
-             ivec_resize=d("ivec_resize", [T_ptr(T_opaque_ivec()), T_int()],
+                          ~[taskptr_type, T_int(), T_int(), T_size_t()],
+                            taskptr_type),
+             ivec_resize=d("ivec_resize", ~[T_ptr(T_opaque_ivec()), T_int()],
                            T_void()),
-             ivec_spill=d("ivec_spill", [T_ptr(T_opaque_ivec()), T_int()],
+             ivec_spill=d("ivec_spill", ~[T_ptr(T_opaque_ivec()), T_int()],
                           T_void()),
              ivec_resize_shared=d("ivec_resize_shared",
-                           [T_ptr(T_opaque_ivec()), T_int()], T_void()),
+                           ~[T_ptr(T_opaque_ivec()), T_int()], T_void()),
              ivec_spill_shared=d("ivec_spill_shared",
-                          [T_ptr(T_opaque_ivec()), T_int()], T_void()));
+                          ~[T_ptr(T_opaque_ivec()), T_int()], T_void()));
 }
 //
 // Local Variables:
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index abf7e99a57d..83e775c847d 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -301,8 +301,12 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
    @session::options {
     auto library = opt_present(match, "lib");
     auto static = opt_present(match, "static");
-    auto library_search_paths = [binary_dir + "/lib"];
-    library_search_paths += getopts::opt_strs(match, "L");
+
+    auto library_search_paths = ~[binary_dir + "/lib"];
+    // FIXME: Remove this vec->ivec conversion.
+    auto lsp_vec = getopts::opt_strs(match, "L");
+    for (str lsp in lsp_vec) { library_search_paths += ~[lsp]; }
+
     auto output_type =
         if (opt_present(match, "parse-only")) {
             link::output_type_none
@@ -398,7 +402,7 @@ fn opts() -> vec[getopts::opt] {
 }
 
 fn main(vec[str] args) {
-    auto binary = vec::shift[str](args);
+    auto binary = vec::shift(args);
     auto binary_dir = fs::dirname(binary);
     auto match =
         alt (getopts::getopts(args, opts())) {
@@ -554,7 +558,10 @@ fn main(vec[str] args) {
         gcc_args += ["-l" + libarg];
     }
 
-    gcc_args += cstore::get_used_link_args(cstore);
+    // FIXME: Remove this ivec->vec conversion.
+    auto ula = cstore::get_used_link_args(cstore);
+    for (str arg in ula) { gcc_args += [arg]; }
+
     auto used_libs = cstore::get_used_libraries(cstore);
     for (str l in used_libs) {
         gcc_args += ["-l" + l];
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index 1689d35c4ad..f07fbc6f859 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -10,7 +10,6 @@ import std::option;
 import std::option::some;
 import std::option::none;
 import std::str;
-import std::vec;
 import syntax::parse::parser::parse_sess;
 
 tag os { os_win32; os_macos; os_linux; }
@@ -36,14 +35,14 @@ type options =
         bool time_passes,
         bool time_llvm_passes,
         back::link::output_type output_type,
-        vec[str] library_search_paths,
+        str[] library_search_paths,
         str sysroot,
         // The crate config requested for the session, which may be combined
         // with additional crate configurations during the compile process
         ast::crate_cfg cfg,
         bool test);
 
-type crate_metadata = rec(str name, vec[u8] data);
+type crate_metadata = rec(str name, u8[] data);
 
 obj session(@config targ_cfg,
             @options opts,
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index 9e5ae8ff27b..33b160c5c1f 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -14,7 +14,6 @@ import back::x86;
 import util::common;
 import std::ivec;
 import std::str;
-import std::vec;
 import std::fs;
 import std::ioivec;
 import std::option;
@@ -47,7 +46,7 @@ fn read_crates(session::session sess,
 type env =
     @rec(session::session sess,
          @hashmap[str, int] crate_cache,
-         vec[str] library_search_paths,
+         str[] library_search_paths,
          mutable ast::crate_num next_crate_num);
 
 fn visit_view_item(env e, &@ast::view_item i) {
@@ -128,7 +127,7 @@ fn default_native_lib_naming(session::session sess, bool static) ->
 
 fn find_library_crate(&session::session sess, &ast::ident ident,
                       &(@ast::meta_item)[] metas,
-                      &vec[str] library_search_paths)
+                      &str[] library_search_paths)
         -> option::t[tup(str, @u8[])] {
 
     attr::require_unique_names(sess, metas);
@@ -162,7 +161,7 @@ fn find_library_crate(&session::session sess, &ast::ident ident,
 
 fn find_library_crate_aux(&rec(str prefix, str suffix) nn, str crate_name,
                           &(@ast::meta_item)[] metas,
-                          &vec[str] library_search_paths) ->
+                          &str[] library_search_paths) ->
                           option::t[tup(str, @u8[])] {
     let str prefix = nn.prefix + crate_name;
     // FIXME: we could probably use a 'glob' function in std::fs but it will
@@ -220,7 +219,7 @@ fn get_metadata_section(str filename) -> option::t[@u8[]] {
 
 fn load_library_crate(&session::session sess, span span,
                       &ast::ident ident, &(@ast::meta_item)[] metas,
-                      &vec[str] library_search_paths) -> tup(str, @u8[]) {
+                      &str[] library_search_paths) -> tup(str, @u8[]) {
 
     alt (find_library_crate(sess, ident, metas, library_search_paths)) {
         case (some(?t)) {
diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs
index f051f164130..f2f24b9b71f 100644
--- a/src/comp/metadata/csearch.rs
+++ b/src/comp/metadata/csearch.rs
@@ -26,7 +26,7 @@ fn get_type_param_count(&cstore::cstore cstore, &ast::def_id def) -> uint {
 }
 
 fn lookup_defs(&cstore::cstore cstore, ast::crate_num cnum,
-               vec[ast::ident] path) -> vec[ast::def] {
+               &ast::ident[] path) -> ast::def[] {
     auto cdata = cstore::get_crate_data(cstore, cnum).data;
     ret decoder::lookup_defs(cdata, cnum, path);
 }
diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs
index 9c743125a01..7f150c088b1 100644
--- a/src/comp/metadata/cstore.rs
+++ b/src/comp/metadata/cstore.rs
@@ -1,8 +1,8 @@
 // The crate store - a central repo for information collected about external
 // crates and libraries
 
+import std::ivec;
 import std::map;
-import std::vec;
 import std::str;
 import syntax::ast;
 
@@ -42,9 +42,9 @@ tag cstore {
 
 type cstore_private = @rec(map::hashmap[ast::crate_num, crate_metadata] metas,
                            use_crate_map use_crate_map,
-                           mutable vec[str] used_crate_files,
-                           mutable vec[str] used_libraries,
-                           mutable vec[str] used_link_args);
+                           mutable str[] used_crate_files,
+                           mutable str[] used_libraries,
+                           mutable str[] used_link_args);
 
 // Map from node_id's of local use statements to crate numbers
 type use_crate_map = map::hashmap[ast::node_id, ast::crate_num];
@@ -61,9 +61,9 @@ fn mk_cstore() -> cstore {
     auto crate_map = map::new_int_hash[ast::crate_num]();
     ret private(@rec(metas = meta_cache,
                      use_crate_map = crate_map,
-                     mutable used_crate_files = [],
-                     mutable used_libraries = [],
-                     mutable used_link_args = []));
+                     mutable used_crate_files = ~[],
+                     mutable used_libraries = ~[],
+                     mutable used_link_args = ~[]));
 }
 
 fn get_crate_data(&cstore cstore, ast::crate_num cnum) -> crate_metadata {
@@ -86,35 +86,39 @@ iter iter_crate_data(&cstore cstore) -> @tup(ast::crate_num, crate_metadata) {
 }
 
 fn add_used_crate_file(&cstore cstore, &str lib) {
-    if (!vec::member(lib, p(cstore).used_crate_files)) {
-        p(cstore).used_crate_files += [lib];
+    if (!ivec::member(lib, p(cstore).used_crate_files)) {
+        p(cstore).used_crate_files += ~[lib];
     }
 }
 
-fn get_used_crate_files(&cstore cstore) -> vec[str] {
+fn get_used_crate_files(&cstore cstore) -> str[] {
     ret p(cstore).used_crate_files;
 }
 
 fn add_used_library(&cstore cstore, &str lib) -> bool {
     if (lib == "") { ret false; }
 
-    if (vec::member(lib, p(cstore).used_libraries)) {
+    if (ivec::member(lib, p(cstore).used_libraries)) {
         ret false;
     }
 
-    p(cstore).used_libraries += [lib];
+    p(cstore).used_libraries += ~[lib];
     ret true;
 }
 
-fn get_used_libraries(&cstore cstore) -> vec[str] {
+fn get_used_libraries(&cstore cstore) -> str[] {
     ret p(cstore).used_libraries;
 }
 
 fn add_used_link_args(&cstore cstore, &str args) {
-    p(cstore).used_link_args += str::split(args, ' ' as u8);
+    auto used_link_args_vec = str::split(args, ' ' as u8);
+    // TODO: Remove this vec->ivec conversion.
+    for (str ula in used_link_args_vec) {
+        p(cstore).used_link_args += ~[ula];
+    }
 }
 
-fn get_used_link_args(&cstore cstore) -> vec[str] {
+fn get_used_link_args(&cstore cstore) -> str[] {
     ret p(cstore).used_link_args;
 }
 
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index 4dc8f0dfdc4..14c69503175 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -3,7 +3,6 @@
 import std::ebmlivec;
 import std::ivec;
 import std::option;
-import std::vec;
 import std::str;
 import std::ioivec;
 import std::map::hashmap;
@@ -125,38 +124,38 @@ fn item_ty_param_count(&ebmlivec::doc item) -> uint {
 }
 
 fn tag_variant_ids(&ebmlivec::doc item,
-                   ast::crate_num this_cnum) -> vec[ast::def_id] {
-    let vec[ast::def_id] ids = [];
+                   ast::crate_num this_cnum) -> ast::def_id[] {
+    let ast::def_id[] ids = ~[];
     auto v = tag_items_data_item_variant;
     for each (ebmlivec::doc p in ebmlivec::tagged_docs(item, v)) {
         auto ext = parse_def_id(ebmlivec::doc_data(p));
-        vec::push[ast::def_id](ids, tup(this_cnum, ext._1));
+        ids += ~[tup(this_cnum, ext._1)];
     }
     ret ids;
 }
 
 // Given a path and serialized crate metadata, returns the ID of the
 // definition the path refers to.
-fn resolve_path(vec[ast::ident] path, @u8[] data) -> vec[ast::def_id] {
+fn resolve_path(&ast::ident[] path, @u8[] data) -> ast::def_id[] {
     fn eq_item(&u8[] data, str s) -> bool {
         ret str::eq(str::unsafe_from_bytes_ivec(data), s);
     }
-    auto s = str::connect(path, "::");
+    auto s = str::connect_ivec(path, "::");
     auto md = ebmlivec::new_doc(data);
     auto paths = ebmlivec::get_doc(md, tag_paths);
     auto eqer = bind eq_item(_, s);
-    let vec[ast::def_id] result = [];
+    let ast::def_id[] result = ~[];
     for (ebmlivec::doc doc in lookup_hash(paths, eqer, hash_path(s))) {
         auto did_doc = ebmlivec::get_doc(doc, tag_def_id);
-        vec::push(result, parse_def_id(ebmlivec::doc_data(did_doc)));
+        result += ~[parse_def_id(ebmlivec::doc_data(did_doc))];
     }
     ret result;
 }
 
 // Crate metadata queries
-fn lookup_defs(&@u8[] data, ast::crate_num cnum,
-               vec[ast::ident] path) -> vec[ast::def] {
-    ret vec::map(bind lookup_def(cnum, data, _), resolve_path(path, data));
+fn lookup_defs(&@u8[] data, ast::crate_num cnum, &ast::ident[] path)
+        -> ast::def[] {
+    ret ivec::map(bind lookup_def(cnum, data, _), resolve_path(path, data));
 }
 
 
@@ -352,8 +351,8 @@ fn get_crate_attributes(@u8[] data) -> ast::attribute[] {
 
 type crate_dep = tup(ast::crate_num, str);
 
-fn get_crate_deps(@u8[] data) -> vec[crate_dep] {
-    let vec[crate_dep] deps = [];
+fn get_crate_deps(@u8[] data) -> crate_dep[] {
+    let crate_dep[] deps = ~[];
     auto cratedoc = ebmlivec::new_doc(data);
     auto depsdoc = ebmlivec::get_doc(cratedoc, tag_crate_deps);
     auto crate_num = 1;
@@ -361,7 +360,7 @@ fn get_crate_deps(@u8[] data) -> vec[crate_dep] {
               ebmlivec::tagged_docs(depsdoc, tag_crate_dep)) {
         auto depname =
             str::unsafe_from_bytes_ivec(ebmlivec::doc_data(depdoc));
-        deps += [tup(crate_num, depname)];
+        deps += ~[tup(crate_num, depname)];
         crate_num += 1;
     }
     ret deps;
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 1c249475868..b4d96d17a3e 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -2,7 +2,6 @@
 
 import std::ivec;
 import std::str;
-import std::vec;
 import std::uint;
 import std::option;
 import std::option::none;
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index e5b42c7f907..5581640251d 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -7,7 +7,7 @@ import ast::def_id;
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
-import std::vec;
+import std::ivec;
 import std::str;
 import std::option;
 import std::option::some;
@@ -25,14 +25,14 @@ import std::option::is_none;
 tag valid { valid; overwritten(span, ast::path); val_taken(span, ast::path); }
 
 type restrict =
-    @rec(vec[node_id] root_vars,
+    @rec(node_id[] root_vars,
          node_id block_defnum,
-         vec[node_id] bindings,
-         vec[ty::t] tys,
-         vec[uint] depends_on,
+         node_id[] bindings,
+         ty::t[] tys,
+         uint[] depends_on,
          mutable valid ok);
 
-type scope = vec[restrict];
+type scope = @restrict[];
 
 tag local_info { arg(ast::mode); objfield(ast::mutability); }
 
@@ -50,7 +50,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
              visit_expr=bind visit_expr(cx, _, _, _),
              visit_decl=bind visit_decl(cx, _, _, _)
              with *visit::default_visitor[scope]());
-    visit::visit_crate(*crate, [], visit::mk_vt(v));
+    visit::visit_crate(*crate, @~[], visit::mk_vt(v));
     tcx.sess.abort_if_errors();
 }
 
@@ -60,7 +60,7 @@ fn visit_fn(&@ctx cx, &ast::_fn f, &ast::ty_param[] tp, &span sp,
     for (ast::arg arg_ in f.decl.inputs) {
         cx.local_map.insert(arg_.id, arg(arg_.mode));
     }
-    v.visit_block(f.body, [], v);
+    v.visit_block(f.body, @~[], v);
 }
 
 fn visit_item(&@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) {
@@ -148,13 +148,13 @@ fn visit_decl(&@ctx cx, &@ast::decl d, &scope sc, &vt[scope] v) {
 }
 
 fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) ->
-   rec(vec[node_id] root_vars, vec[ty::t] unsafe_ts) {
+   rec(node_id[] root_vars, ty::t[] unsafe_ts) {
     auto fty = ty::expr_ty(*cx.tcx, f);
     auto arg_ts = fty_args(cx, fty);
-    let vec[node_id] roots = [];
-    let vec[tup(uint, node_id)] mut_roots = [];
-    let vec[ty::t] unsafe_ts = [];
-    let vec[uint] unsafe_t_offsets = [];
+    let node_id[] roots = ~[];
+    let tup(uint, node_id)[] mut_roots = ~[];
+    let ty::t[] unsafe_ts = ~[];
+    let uint[] unsafe_t_offsets = ~[];
     auto i = 0u;
     for (ty::arg arg_t in arg_ts) {
         if (arg_t.mode != ty::mo_val) {
@@ -162,34 +162,31 @@ fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) ->
             auto root = expr_root(cx, arg, false);
             if (arg_t.mode == ty::mo_alias(true)) {
                 alt (path_def_id(cx, arg)) {
-                    case (some(?did)) {
-                        vec::push(mut_roots, tup(i, did._1));
-                    }
-                    case (_) {
-                        if (!mut_field(root.ds)) {
-                            auto m =
-                                "passing a temporary value or \
+                  some(?did) { mut_roots += ~[tup(i, did._1)]; }
+                  _ {
+                    if (!mut_field(root.ds)) {
+                        auto m = "passing a temporary value or \
                                  immutable field by mutable alias";
-                            cx.tcx.sess.span_err(arg.span, m);
-                        }
+                        cx.tcx.sess.span_err(arg.span, m);
                     }
+                  }
                 }
             }
             alt (path_def_id(cx, root.ex)) {
-                case (some(?did)) { vec::push(roots, did._1); }
-                case (_) { }
+              some(?did) { roots += ~[did._1]; }
+              _ { }
             }
             alt (inner_mut(root.ds)) {
-                case (some(?t)) {
-                    vec::push(unsafe_ts, t);
-                    vec::push(unsafe_t_offsets, i);
-                }
-                case (_) { }
+              some(?t) {
+                unsafe_ts += ~[t];
+                unsafe_t_offsets += ~[i];
+              }
+              _ { }
             }
         }
         i += 1u;
     }
-    if (vec::len(unsafe_ts) > 0u) {
+    if (ivec::len(unsafe_ts) > 0u) {
         alt (f.node) {
             case (ast::expr_path(_)) {
                 if (def_is_local(cx.tcx.def_map.get(f.id), true)) {
@@ -223,12 +220,18 @@ fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) ->
     // Ensure we're not passing a root by mutable alias.
 
     for (tup(uint, node_id) root in mut_roots) {
-        auto mut_alias_to_root = vec::count(root._1, roots) > 1u;
-        for (restrict r in sc) {
-            if (vec::member(root._1, r.root_vars)) {
-                mut_alias_to_root = true;
+        auto mut_alias_to_root = false;
+        auto mut_alias_to_root_count = 0u;
+        for (node_id r in roots) {
+            if root._1 == r {
+                mut_alias_to_root_count += 1u;
+                if mut_alias_to_root_count > 1u {
+                    mut_alias_to_root = true;
+                    break;
+                }
             }
         }
+
         if (mut_alias_to_root) {
             cx.tcx.sess.span_err(args.(root._0).span,
                                  "passing a mutable alias to a \
@@ -281,31 +284,31 @@ fn check_alt(&ctx cx, &@ast::expr input, &ast::arm[] arms, &scope sc,
     visit::visit_expr(input, sc, v);
     auto root = expr_root(cx, input, true);
     auto roots = alt (path_def_id(cx, root.ex)) {
-        some(?did) { [did._1] }
-        _ { [] }
+      some(?did) { ~[did._1] }
+      _ { ~[] }
     };
-    let vec[ty::t] forbidden_tp =
-        alt (inner_mut(root.ds)) { some(?t) { [t] } _ { [] } };
+    let ty::t[] forbidden_tp =
+        alt (inner_mut(root.ds)) { some(?t) { ~[t] } _ { ~[] } };
     for (ast::arm a in arms) {
         auto dnums = arm_defnums(a);
         auto new_sc = sc;
-        if (vec::len(dnums) > 0u) {
-            new_sc = sc + [@rec(root_vars=roots,
-                                block_defnum=dnums.(0),
-                                bindings=dnums,
-                                tys=forbidden_tp,
-                                depends_on=deps(sc, roots),
-                                mutable ok=valid)];
+        if (ivec::len(dnums) > 0u) {
+            new_sc = @(*sc + ~[@rec(root_vars=roots,
+                                    block_defnum=dnums.(0),
+                                    bindings=dnums,
+                                    tys=forbidden_tp,
+                                    depends_on=deps(sc, roots),
+                                    mutable ok=valid)]);
         }
         visit::visit_arm(a, new_sc, v);
     }
 }
 
-fn arm_defnums(&ast::arm arm) -> vec[node_id] {
-    auto dnums = [];
-    fn walk_pat(&mutable vec[node_id] found, &@ast::pat p) {
+fn arm_defnums(&ast::arm arm) -> node_id[] {
+    auto dnums = ~[];
+    fn walk_pat(&mutable node_id[] found, &@ast::pat p) {
         alt (p.node) {
-            case (ast::pat_bind(_)) { vec::push(found, p.id); }
+            case (ast::pat_bind(_)) { found += ~[p.id]; }
             case (ast::pat_tag(_, ?children)) {
                 for (@ast::pat child in children) { walk_pat(found, child); }
             }
@@ -330,11 +333,11 @@ fn check_for_each(&ctx cx, &@ast::local local, &@ast::expr call,
             auto new_sc =
                 @rec(root_vars=data.root_vars,
                      block_defnum=defnum,
-                     bindings=[defnum],
+                     bindings=~[defnum],
                      tys=data.unsafe_ts,
                      depends_on=deps(sc, data.root_vars),
                      mutable ok=valid);
-            visit::visit_block(block, sc + [new_sc], v);
+            visit::visit_block(block, @(*sc + ~[new_sc]), v);
         }
     }
 }
@@ -345,16 +348,16 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
     auto defnum = local.node.id;
     auto root = expr_root(cx, seq, false);
     auto root_def = alt (path_def_id(cx, root.ex)) {
-        some(?did) { [did._1] }
-        _ { [] }
+      some(?did) { ~[did._1] }
+      _ { ~[] }
     };
-    auto unsafe = alt (inner_mut(root.ds)) { some(?t) { [t] } _ { [] } };
+    auto unsafe = alt (inner_mut(root.ds)) { some(?t) { ~[t] } _ { ~[] } };
 
     // If this is a mutable vector, don't allow it to be touched.
     auto seq_t = ty::expr_ty(*cx.tcx, seq);
     alt (ty::struct(*cx.tcx, seq_t)) {
         ty::ty_vec(?mt) | ty::ty_ivec(?mt) {
-            if (mt.mut != ast::imm) { unsafe = [seq_t]; }
+            if (mt.mut != ast::imm) { unsafe = ~[seq_t]; }
         }
         ty::ty_str | ty::ty_istr { /* no-op */ }
         _ {
@@ -365,11 +368,11 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
     auto new_sc =
         @rec(root_vars=root_def,
              block_defnum=defnum,
-             bindings=[defnum],
+             bindings=~[defnum],
              tys=unsafe,
              depends_on=deps(sc, root_def),
              mutable ok=valid);
-    visit::visit_block(block, sc + [new_sc], v);
+    visit::visit_block(block, @(*sc + ~[new_sc]), v);
 }
 
 fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id,
@@ -378,7 +381,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id,
     if (!def_is_local(def, true)) { ret; }
     auto my_defnum = ast::def_id_of_def(def)._1;
     auto var_t = ty::expr_ty(*cx.tcx, ex);
-    for (restrict r in sc) {
+    for (restrict r in *sc) {
         // excludes variables introduced since the alias was made
         if (my_defnum < r.block_defnum) {
             for (ty::t t in r.tys) {
@@ -386,7 +389,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id,
                     r.ok = val_taken(ex.span, p);
                 }
             }
-        } else if (vec::member(my_defnum, r.bindings)) {
+        } else if (ivec::member(my_defnum, r.bindings)) {
             test_scope(cx, sc, r, p);
         }
     }
@@ -403,15 +406,15 @@ fn check_lval(&@ctx cx, &@ast::expr dest, &scope sc, &vt[scope] v) {
                 cx.tcx.sess.span_err(dest.span,
                                      "assigning to immutable obj field");
             }
-            for (restrict r in sc) {
-                if (vec::member(dnum, r.root_vars)) {
+            for (restrict r in *sc) {
+                if (ivec::member(dnum, r.root_vars)) {
                     r.ok = overwritten(dest.span, p);
                 }
             }
         }
         case (_) {
             auto root = expr_root(*cx, dest, false);
-            if (vec::len(root.ds) == 0u) {
+            if (ivec::len(*root.ds) == 0u) {
                 cx.tcx.sess.span_err(dest.span, "assignment to non-lvalue");
             } else if (!root.ds.(0).mut) {
                 auto name =
@@ -443,7 +446,7 @@ fn check_move_rhs(&@ctx cx, &@ast::expr src, &scope sc, &vt[scope] v) {
         case (_) {
             auto root = expr_root(*cx, src, false);
             // Not a path and no-derefs means this is a temporary.
-            if (vec::len(root.ds) != 0u) {
+            if (ivec::len(*root.ds) != 0u) {
                 cx.tcx.sess.span_err
                     (src.span, "moving out of a data structure");
             }
@@ -463,8 +466,8 @@ fn is_immutable_alias(&@ctx cx, &scope sc, node_id dnum) -> bool {
         case (some(arg(ast::alias(false)))) { ret true; }
         case (_) { }
     }
-    for (restrict r in sc) {
-        if (vec::member(dnum, r.bindings)) { ret true; }
+    for (restrict r in *sc) {
+        if (ivec::member(dnum, r.bindings)) { ret true; }
     }
     ret false;
 }
@@ -495,12 +498,12 @@ fn test_scope(&ctx cx, &scope sc, &restrict r, &ast::path p) {
     }
 }
 
-fn deps(&scope sc, vec[node_id] roots) -> vec[uint] {
+fn deps(&scope sc, &node_id[] roots) -> uint[] {
     auto i = 0u;
-    auto result = [];
-    for (restrict r in sc) {
+    auto result = ~[];
+    for (restrict r in *sc) {
         for (node_id dn in roots) {
-            if (vec::member(dn, r.bindings)) { vec::push(result, i); }
+            if ivec::member(dn, r.bindings) { result += ~[i]; }
         }
         i += 1u;
     }
@@ -509,7 +512,7 @@ fn deps(&scope sc, vec[node_id] roots) -> vec[uint] {
 
 tag deref_t { unbox; field; index; }
 
-type deref = rec(bool mut, deref_t kind, ty::t outer_t);
+type deref = @rec(bool mut, deref_t kind, ty::t outer_t);
 
 
 // Finds the root (the thing that is dereferenced) for the given expr, and a
@@ -517,23 +520,23 @@ type deref = rec(bool mut, deref_t kind, ty::t outer_t);
 // the inner derefs come in front, so foo.bar.baz becomes rec(ex=foo,
 // ds=[field(baz),field(bar)])
 fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
-   rec(@ast::expr ex, vec[deref] ds) {
+   rec(@ast::expr ex, @deref[] ds) {
     fn maybe_auto_unbox(&ctx cx, &ty::t t) ->
        rec(ty::t t, option::t[deref] d) {
         alt (ty::struct(*cx.tcx, t)) {
             case (ty::ty_box(?mt)) {
                 ret rec(t=mt.ty,
-                        d=some(rec(mut=mt.mut != ast::imm,
-                                   kind=unbox,
-                                   outer_t=t)));
+                        d=some(@rec(mut=mt.mut != ast::imm,
+                                    kind=unbox,
+                                    outer_t=t)));
             }
             case (_) { ret rec(t=t, d=none); }
         }
     }
-    fn maybe_push_auto_unbox(&option::t[deref] d, &mutable vec[deref] ds) {
-        alt (d) { case (some(?d)) { vec::push(ds, d); } case (none) { } }
+    fn maybe_push_auto_unbox(&option::t[deref] d, &mutable deref[] ds) {
+        alt (d) { case (some(?d)) { ds += ~[d]; } case (none) { } }
     }
-    let vec[deref] ds = [];
+    let deref[] ds = ~[];
     while (true) {
         alt ({ ex.node }) {
             case (ast::expr_field(?base, ?ident)) {
@@ -555,7 +558,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
                     }
                     case (ty::ty_obj(_)) { }
                 }
-                vec::push(ds, rec(mut=mut, kind=field, outer_t=auto_unbox.t));
+                ds += ~[@rec(mut=mut, kind=field, outer_t=auto_unbox.t)];
                 maybe_push_auto_unbox(auto_unbox.d, ds);
                 ex = base;
             }
@@ -564,14 +567,14 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
                     maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, base));
                 alt (ty::struct(*cx.tcx, auto_unbox.t)) {
                     case (ty::ty_vec(?mt)) {
-                        vec::push(ds, rec(mut=mt.mut != ast::imm,
-                                          kind=index,
-                                          outer_t=auto_unbox.t));
+                        ds += ~[@rec(mut=mt.mut != ast::imm,
+                                    kind=index,
+                                    outer_t=auto_unbox.t)];
                     }
                     case (ty::ty_ivec(?mt)) {
-                        vec::push(ds, rec(mut=mt.mut != ast::imm,
-                                          kind=index,
-                                          outer_t=auto_unbox.t));
+                        ds += ~[@rec(mut=mt.mut != ast::imm,
+                                    kind=index,
+                                    outer_t=auto_unbox.t)];
                     }
                 }
                 maybe_push_auto_unbox(auto_unbox.d, ds);
@@ -587,7 +590,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
                         case (ty::ty_tag(_, _)) {}
                         case (ty::ty_ptr(?mt)) { mut = mt.mut != ast::imm; }
                     }
-                    vec::push(ds, rec(mut=mut, kind=unbox, outer_t=base_t));
+                    ds += ~[@rec(mut=mut, kind=unbox, outer_t=base_t)];
                     ex = base;
                 } else { break; }
             }
@@ -598,16 +601,16 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
         auto auto_unbox = maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, ex));
         maybe_push_auto_unbox(auto_unbox.d, ds);
     }
-    ret rec(ex=ex, ds=ds);
+    ret rec(ex=ex, ds=@ds);
 }
 
-fn mut_field(&vec[deref] ds) -> bool {
-    for (deref d in ds) { if (d.mut) { ret true; } }
+fn mut_field(&@deref[] ds) -> bool {
+    for (deref d in *ds) { if (d.mut) { ret true; } }
     ret false;
 }
 
-fn inner_mut(&vec[deref] ds) -> option::t[ty::t] {
-    for (deref d in ds) { if (d.mut) { ret some(d.outer_t); } }
+fn inner_mut(&@deref[] ds) -> option::t[ty::t] {
+    for (deref d in *ds) { if (d.mut) { ret some(d.outer_t); } }
     ret none;
 }
 
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index d32e4b7f4e7..a0fbc6a7061 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -1168,11 +1168,7 @@ fn ns_for_def(def d) -> namespace {
 
 fn lookup_external(&env e, int cnum, &ident[] ids, namespace ns) ->
    option::t[def] {
-    // FIXME: Remove this ivec->vec conversion.
-    auto ids_vec = [];
-    for (ident i in ids) { ids_vec += [i]; }
-
-    for (def d in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids_vec)) {
+    for (def d in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids)) {
         e.ext_map.insert(ast::def_id_of_def(d), ids);
         if (ns == ns_for_def(d)) { ret some(d); }
     }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 54c662851aa..2ef71234fdd 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1364,7 +1364,7 @@ fn check_pat(&@fn_ctxt fcx, &ast::pat_id_map map, &@ast::pat pat,
                         fcx.ccx.tcx.sess.span_fatal(pat.span, s);
                     }
 
-                    // TODO: vec::iter2
+                    // TODO: ivec::iter2
 
                     auto i = 0u;
                     for (@ast::pat subpat in subpats) {
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 46105f5320e..92639819aa9 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -1,6 +1,6 @@
+import std::ivec;
 import std::uint;
 import std::str;
-import std::vec;
 import std::termivec;
 import std::ioivec;
 import std::option;
@@ -14,33 +14,33 @@ type filename = str;
  * with single-word things, rather than passing records all over the
  * compiler.
  */
-type filemap = @rec(filename name, uint start_pos, mutable vec[uint] lines);
+type filemap = @rec(filename name, uint start_pos, mutable uint[] lines);
 
-type codemap = @rec(mutable vec[filemap] files);
+type codemap = @rec(mutable filemap[] files);
 
 type loc = rec(filename filename, uint line, uint col);
 
 fn new_codemap() -> codemap {
-    let vec[filemap] files = [];
+    let filemap[] files = ~[];
     ret @rec(mutable files=files);
 }
 
 fn new_filemap(filename filename, uint start_pos) -> filemap {
-    ret @rec(name=filename, start_pos=start_pos, mutable lines=[0u]);
+    ret @rec(name=filename, start_pos=start_pos, mutable lines=~[0u]);
 }
 
-fn next_line(filemap file, uint pos) { vec::push[uint](file.lines, pos); }
+fn next_line(filemap file, uint pos) { file.lines += ~[pos]; }
 
 fn lookup_pos(codemap map, uint pos) -> loc {
     auto a = 0u;
-    auto b = vec::len[filemap](map.files);
+    auto b = ivec::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);
+    b = ivec::len[uint](f.lines);
     while (b - a > 1u) {
         auto m = (a + b) / 2u;
         if (f.lines.(m) > pos) { b = m; } else { a = m; }
@@ -91,8 +91,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
             auto max_lines = 6u;
             auto elided = false;
             auto display_lines = lines.lines;
-            if (vec::len(display_lines) > max_lines) {
-                display_lines = vec::slice(display_lines, 0u, max_lines);
+            if (ivec::len(display_lines) > max_lines) {
+                display_lines = ivec::slice(display_lines, 0u, max_lines);
                 elided = true;
             }
             // Print the offending lines
@@ -106,7 +106,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
                 ioivec::stdout().write_str(s);
             }
             if (elided) {
-                auto last_line = display_lines.(vec::len(display_lines) - 1u);
+                auto last_line = display_lines.(ivec::len(display_lines) -
+                                                1u);
                 auto s = #fmt("%s:%u ", fm.name, last_line + 1u);
                 auto indent = str::char_len(s);
                 auto out = "";
@@ -116,7 +117,7 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
             }
 
             // If there's one line at fault we can easily point to the problem
-            if (vec::len(lines.lines) == 1u) {
+            if (ivec::len(lines.lines) == 1u) {
                 auto lo = codemap::lookup_pos(cm, option::get(sp).lo);
                 auto digits = 0u;
                 auto num = lines.lines.(0) / 10u;
@@ -156,21 +157,21 @@ fn emit_note(&option::t[span] sp, &str msg, &codemap cm) {
     emit_diagnostic(sp, msg, "note", 10u8, cm);
 }
 
-type file_lines = rec(str name, vec[uint] lines);
+type file_lines = rec(str name, uint[] lines);
 
 fn span_to_lines(span sp, codemap::codemap cm) -> @file_lines {
     auto lo = codemap::lookup_pos(cm, sp.lo);
     auto hi = codemap::lookup_pos(cm, sp.hi);
-    auto lines = [];
+    auto lines = ~[];
     for each (uint i in uint::range(lo.line - 1u, hi.line as uint)) {
-        lines += [i];
+        lines += ~[i];
     }
     ret @rec(name=lo.filename, lines=lines);
 }
 
 fn get_line(filemap fm, int line, &str file) -> str {
     let uint end;
-    if ((line as uint) + 1u >= vec::len(fm.lines)) {
+    if ((line as uint) + 1u >= ivec::len(fm.lines)) {
         end = str::byte_len(file);
     } else {
         end = fm.lines.(line + 1);
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 226d84233e0..5488867dcdd 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -1,5 +1,4 @@
 
-import std::vec;
 import std::str;
 import std::option;
 import std::option::some;
@@ -19,7 +18,7 @@ tag eval_mode { mode_depend; mode_parse; }
 type ctx =
     @rec(parser p,
          eval_mode mode,
-         mutable vec[str] deps,
+         mutable str[] deps,
          parser::parse_sess sess,
          mutable uint chpos,
          ast::crate_cfg cfg);
@@ -55,7 +54,7 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
             } else {
                 prefix + std::fs::path_sep() + file_path
             };
-            if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; }
+            if (cx.mode == mode_depend) { cx.deps += ~[full_path]; ret; }
             auto p0 =
                 new_parser_from_file(cx.sess, cx.cfg, full_path, cx.chpos);
             auto inner_attrs = parse_inner_attrs_and_next(p0);
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 77bde628014..da7c978ba78 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -1,8 +1,8 @@
 
 import std::ioivec;
-import std::str;
-import std::vec;
 import std::int;
+import std::ivec;
+import std::str;
 import std::map;
 import std::map::hashmap;
 import std::option;
@@ -40,7 +40,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
                mutable uint mark_pos,
                mutable uint mark_chpos,
                mutable uint chpos,
-               mutable vec[str] strs,
+               mutable str[] strs,
                codemap::filemap fm,
                @interner::interner[str] itr) {
         fn is_eof() -> bool { ret ch == -1 as char; }
@@ -83,7 +83,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
             codemap::emit_error(some(rec(lo=chpos, hi=chpos)), m, cm);
         }
     }
-    let vec[str] strs = [];
+    let str[] strs = ~[];
     auto rd =
         reader(cm, src, str::byte_len(src), 0u, 0u, -1 as char, 0u,
                filemap.start_pos, filemap.start_pos, strs, filemap, itr);
@@ -578,7 +578,7 @@ tag cmnt_style {
 
 }
 
-type cmnt = rec(cmnt_style style, vec[str] lines, uint pos);
+type cmnt = rec(cmnt_style style, str[] lines, uint pos);
 
 fn read_to_eol(&reader rdr) -> str {
     auto val = "";
@@ -610,7 +610,7 @@ fn consume_whitespace_counting_blank_lines(&reader rdr,
     while (is_whitespace(rdr.curr()) && !rdr.is_eof()) {
         if (rdr.curr() == '\n' && rdr.next() == '\n') {
             log ">>> blank-line comment";
-            let vec[str] v = [];
+            let str[] v = ~[];
             comments += ~[rec(style=blank_line, lines=v,
                               pos=rdr.get_chpos())];
         }
@@ -621,11 +621,11 @@ fn consume_whitespace_counting_blank_lines(&reader rdr,
 fn read_line_comments(&reader rdr, bool code_to_the_left) -> cmnt {
     log ">>> line comments";
     auto p = rdr.get_chpos();
-    let vec[str] lines = [];
+    let str[] lines = ~[];
     while (rdr.curr() == '/' && rdr.next() == '/') {
         auto line = read_one_line_comment(rdr);
         log line;
-        lines += [line];
+        lines += ~[line];
         consume_non_eol_whitespace(rdr);
     }
     log "<<< line comments";
@@ -643,7 +643,7 @@ fn all_whitespace(&str s, uint begin, uint end) -> bool {
     ret true;
 }
 
-fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s,
+fn trim_whitespace_prefix_and_push_line(&mutable str[] lines, &str s,
                                         uint col) {
     auto s1;
     if (all_whitespace(s, 0u, col)) {
@@ -652,13 +652,13 @@ fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s,
         } else { s1 = ""; }
     } else { s1 = s; }
     log "pushing line: " + s1;
-    lines += [s1];
+    lines += ~[s1];
 }
 
 fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt {
     log ">>> block comment";
     auto p = rdr.get_chpos();
-    let vec[str] lines = [];
+    let str[] lines = ~[];
     let uint col = rdr.get_col();
     rdr.bump();
     rdr.bump();
@@ -693,7 +693,7 @@ fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt {
     }
     auto style = if (code_to_the_left) { trailing } else { isolated };
     consume_non_eol_whitespace(rdr);
-    if (!rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u) {
+    if (!rdr.is_eof() && rdr.curr() != '\n' && ivec::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 d238e6eb2e7..2f810f84614 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1,7 +1,6 @@
 
 import std::ioivec;
 import std::ivec;
-import std::vec;
 import std::str;
 import std::option;
 import std::option::some;
@@ -45,7 +44,7 @@ type parser =
         fn get_lo_pos() -> uint ;
         fn get_hi_pos() -> uint ;
         fn get_last_lo_pos() -> uint ;
-        fn get_prec_table() -> vec[op_spec] ;
+        fn get_prec_table() -> @op_spec[] ;
         fn get_str(token::str_num) -> str ;
         fn get_reader() -> lexer::reader ;
         fn get_filemap() -> codemap::filemap ;
@@ -62,7 +61,7 @@ fn new_parser_from_file(parse_sess sess, ast::crate_cfg cfg,
     auto srdr = ioivec::file_reader(path);
     auto src = str::unsafe_from_bytes_ivec(srdr.read_whole_stream());
     auto filemap = codemap::new_filemap(path, pos);
-    vec::push(sess.cm.files, filemap);
+    sess.cm.files += ~[filemap];
     auto itr = @interner::mk(str::hash, str::eq);
     auto rdr = lexer::new_reader(sess.cm, src, filemap, itr);
 
@@ -80,7 +79,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
                      mutable uint last_lo,
                      mutable restriction restr,
                      lexer::reader rdr,
-                     vec[op_spec] precs,
+                     @op_spec[] precs,
                      hashmap[str, ()] bad_words) {
         fn peek() -> token::token { ret tok; }
         fn bump() {
@@ -107,7 +106,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
         fn get_last_lo_pos() -> uint { ret last_lo; }
         fn get_file_type() -> file_type { ret ftype; }
         fn get_cfg() -> ast::crate_cfg { ret cfg; }
-        fn get_prec_table() -> vec[op_spec] { ret precs; }
+        fn get_prec_table() -> @op_spec[] { ret precs; }
         fn get_str(token::str_num i) -> str {
             ret interner::get(*rdr.get_interner(), i);
         }
@@ -258,7 +257,7 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo) -> ast::ty_ {
     }
     auto lo = p.get_lo_pos();
     auto inputs =
-        parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                        parse_fn_input_ty, p);
     auto constrs = parse_constrs(~[], p);
     let @ast::ty output;
@@ -308,7 +307,7 @@ fn parse_ty_obj(&parser p, &mutable uint hi) -> ast::ty_ {
         fail;
     }
     auto f = parse_method_sig;
-    auto meths = parse_seq_ivec(token::LBRACE, token::RBRACE, none, f, p);
+    auto meths = parse_seq(token::LBRACE, token::RBRACE, none, f, p);
     hi = meths.span.hi;
     ret ast::ty_obj(meths.node);
 }
@@ -352,7 +351,7 @@ fn parse_ty_constr(&ast::arg[] fn_args, &parser p) -> @ast::constr {
     auto path = parse_path(p);
     auto pf = bind parse_constr_arg(fn_args, _);
     let rec((@ast::constr_arg)[] node, span span) args =
-        parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), pf,
+        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), pf,
                        p);
     // FIXME fix the def_id
 
@@ -409,12 +408,8 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
 
         if (mut == ast::imm && p.peek() != token::RBRACKET) {
             // This is explicit type parameter instantiation.
-            auto seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA),
-                                        parse_ty, p);
-
-            // FIXME: Remove this vec->ivec conversion.
-            auto seq_ivec = ~[];
-            for (@ast::ty typ in seq) { seq_ivec += ~[typ]; }
+            auto seq = parse_seq_to_end(token::RBRACKET,
+                                             some(token::COMMA), parse_ty, p);
 
             alt (orig_t.node) {
                 case (ast::ty_path(?pth, ?ann)) {
@@ -423,7 +418,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
                                  ast::ty_path(spanned(lo, hi,
                                               rec(global=pth.node.global,
                                                   idents=pth.node.idents,
-                                                  types=seq_ivec)),
+                                                  types=seq)),
                                               ann));
                 }
                 case (_) {
@@ -522,13 +517,13 @@ fn parse_ty(&parser p) -> @ast::ty {
         expect(p, token::RBRACKET);
     } else if (eat_word(p, "tup")) {
         auto elems =
-            parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                            parse_mt, p);
         hi = elems.span.hi;
         t = ast::ty_tup(elems.node);
     } else if (eat_word(p, "rec")) {
         auto elems =
-            parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                            parse_ty_field, p);
         hi = elems.span.hi;
         t = ast::ty_rec(elems.node);
@@ -577,23 +572,6 @@ fn parse_arg(&parser p) -> ast::arg {
 }
 
 fn parse_seq_to_end[T](token::token ket, option::t[token::token] sep,
-                       fn(&parser) -> T  f, &parser p) -> vec[T] {
-    let bool first = true;
-    let vec[T] v = [];
-    while (p.peek() != ket) {
-        alt (sep) {
-            case (some(?t)) {
-                if (first) { first = false; } else { expect(p, t); }
-            }
-            case (_) { }
-        }
-        v += [f(p)];
-    }
-    expect(p, ket);
-    ret v;
-}
-
-fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep,
                             fn(&parser)->T  f, &parser p) -> T[] {
     let bool first = true;
     let T[] v = ~[];
@@ -612,21 +590,11 @@ fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep,
 
 
 fn parse_seq[T](token::token bra, token::token ket,
-                option::t[token::token] sep, fn(&parser) -> T  f, &parser p)
-   -> ast::spanned[vec[T]] {
-    auto lo = p.get_lo_pos();
-    expect(p, bra);
-    auto result = parse_seq_to_end[T](ket, sep, f, p);
-    auto hi = p.get_hi_pos();
-    ret spanned(lo, hi, result);
-}
-
-fn parse_seq_ivec[T](token::token bra, token::token ket,
                      option::t[token::token] sep,
                      fn(&parser)->T  f, &parser p) -> ast::spanned[T[]] {
     auto lo = p.get_lo_pos();
     expect(p, bra);
-    auto result = parse_seq_to_end_ivec[T](ket, sep, f, p);
+    auto result = parse_seq_to_end[T](ket, sep, f, p);
     auto hi = p.get_hi_pos();
     ret spanned(lo, hi, result);
 }
@@ -704,15 +672,10 @@ fn parse_path_and_ty_param_substs(&parser p) -> ast::path {
     if (p.peek() == token::LBRACKET) {
         auto seq = parse_seq(token::LBRACKET, token::RBRACKET,
                              some(token::COMMA), parse_ty, p);
-
-        // FIXME: Remove this vec->ivec conversion.
-        auto seq_ivec = ~[];
-        for (@ast::ty typ in seq.node) { seq_ivec += ~[typ]; }
-
         auto hi = p.get_hi_pos();
         path = spanned(lo, hi, rec(global=path.node.global,
                                    idents=path.node.idents,
-                                   types=seq_ivec));
+                                   types=seq.node));
     }
     ret path;
 }
@@ -793,7 +756,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
             ret rec(mut=m, expr=e);
         }
         auto es =
-            parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                            parse_elt, p);
         hi = es.span.hi;
         ex = ast::expr_tup(es.node);
@@ -801,7 +764,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         p.bump();
         auto mut = parse_mutability(p);
         auto es =
-            parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
+            parse_seq_to_end(token::RBRACKET, some(token::COMMA),
                                   parse_expr, p);
         ex = ast::expr_vec(es, mut, ast::sk_rc);
     } else if (p.peek() == token::POUND_LT) {
@@ -822,7 +785,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
                 p.bump();
                 auto mut = parse_mutability(p);
                 auto es =
-                    parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
+                    parse_seq_to_end(token::RBRACKET, some(token::COMMA),
                                           parse_expr, p);
                 ex = ast::expr_vec(es, mut, ast::sk_unique);
             }
@@ -848,7 +811,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         if (p.peek() == token::LPAREN) {
             p.bump();
             fields =
-                some(parse_seq_to_end_ivec(token::RPAREN, some(token::COMMA),
+                some(parse_seq_to_end(token::RPAREN, some(token::COMMA),
                                            parse_anon_obj_field, p));
         }
         let (@ast::method)[] meths = ~[];
@@ -902,7 +865,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
             }
         }
         auto es =
-            parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                            parse_expr_opt, p);
         hi = es.span.hi;
         ex = ast::expr_bind(e, es.node);
@@ -1003,7 +966,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
 
         let @ast::expr f = parse_self_method(p);
         auto es =
-            parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                            parse_expr, p);
         hi = es.span.hi;
         ex = ast::expr_call(f, es.node);
@@ -1033,7 +996,7 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr {
     if (ivec::len(pth.node.idents) == 0u) {
         p.fatal("expected a syntax expander name");
     }
-    auto es = parse_seq_ivec(token::LPAREN, token::RPAREN,
+    auto es = parse_seq(token::LPAREN, token::RPAREN,
                              some(token::COMMA), parse_expr, p);
     auto hi = es.span.hi;
     ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, es.node, none));
@@ -1061,7 +1024,7 @@ fn parse_dot_or_call_expr_with(&parser p, @ast::expr e) -> @ast::expr {
                     // Call expr.
 
                     auto es =
-                        parse_seq_ivec(token::LPAREN, token::RPAREN,
+                        parse_seq(token::LPAREN, token::RPAREN,
                                        some(token::COMMA), parse_expr, p);
                     hi = es.span.hi;
                     e = mk_expr(p, lo, hi, ast::expr_call(e, es.node));
@@ -1157,27 +1120,27 @@ type op_spec = rec(token::token tok, ast::binop op, int prec);
 
 
 // FIXME make this a const, don't store it in parser state
-fn prec_table() -> vec[op_spec] {
-    ret [rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
-         rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
-         rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
-         rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
-         rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10),
-         rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9),
-         rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9),
-         rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9),
-         rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8),
-         rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6),
-         rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6),
-         // 'as' sits between here with 5
-         rec(tok=token::LT, op=ast::lt, prec=4),
-         rec(tok=token::LE, op=ast::le, prec=4),
-         rec(tok=token::GE, op=ast::ge, prec=4),
-         rec(tok=token::GT, op=ast::gt, prec=4),
-         rec(tok=token::EQEQ, op=ast::eq, prec=3),
-         rec(tok=token::NE, op=ast::ne, prec=3),
-         rec(tok=token::ANDAND, op=ast::and, prec=2),
-         rec(tok=token::OROR, op=ast::or, prec=1)];
+fn prec_table() -> @op_spec[] {
+    ret @~[rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
+           rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
+           rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
+           rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
+           rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10),
+           rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9),
+           rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9),
+           rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9),
+           rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8),
+           rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6),
+           rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6),
+           // 'as' sits between here with 5
+           rec(tok=token::LT, op=ast::lt, prec=4),
+           rec(tok=token::LE, op=ast::le, prec=4),
+           rec(tok=token::GE, op=ast::ge, prec=4),
+           rec(tok=token::GT, op=ast::gt, prec=4),
+           rec(tok=token::EQEQ, op=ast::eq, prec=3),
+           rec(tok=token::NE, op=ast::ne, prec=3),
+           rec(tok=token::ANDAND, op=ast::and, prec=2),
+           rec(tok=token::OROR, op=ast::or, prec=1)];
 }
 
 fn parse_binops(&parser p) -> @ast::expr {
@@ -1191,7 +1154,7 @@ const int ternary_prec = 0;
 
 fn parse_more_binops(&parser p, @ast::expr lhs, int min_prec) -> @ast::expr {
     auto peeked = p.peek();
-    for (op_spec cur in p.get_prec_table()) {
+    for (op_spec cur in *p.get_prec_table()) {
         if (cur.prec > min_prec && cur.tok == peeked) {
             p.bump();
             auto rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec);
@@ -1378,7 +1341,7 @@ fn parse_spawn_expr(&parser p) -> @ast::expr {
 
     auto fn_expr = parse_bottom_expr(p);
     auto es =
-        parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                        parse_expr, p);
     auto hi = es.span.hi;
     ret mk_expr(p, lo, hi, ast::expr_spawn
@@ -1515,7 +1478,7 @@ fn parse_pat(&parser p) -> @ast::pat {
                     case (token::LPAREN) {
                         auto f = parse_pat;
                         auto a =
-                            parse_seq_ivec(token::LPAREN, token::RPAREN,
+                            parse_seq(token::LPAREN, token::RPAREN,
                                            some(token::COMMA), f, p);
                         args = a.node;
                         hi = a.span.hi;
@@ -1763,7 +1726,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] {
     let ast::ty_param[] ty_params = ~[];
     if (p.peek() == token::LBRACKET) {
         ty_params =
-            parse_seq_ivec(token::LBRACKET, token::RBRACKET,
+            parse_seq(token::LBRACKET, token::RBRACKET,
                            some(token::COMMA), parse_ty_param, p).node;
     }
     ret ty_params;
@@ -1771,7 +1734,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] {
 
 fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
     let ast::spanned[ast::arg[]] inputs =
-        parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                        parse_arg, p);
     let ty_or_bang rslt;
     auto constrs = parse_constrs(inputs.node, p).node;
@@ -1879,7 +1842,7 @@ fn parse_item_obj(&parser p, ast::layer lyr, &ast::attribute[] attrs) ->
     auto ident = parse_value_ident(p);
     auto ty_params = parse_ty_params(p);
     let ast::spanned[ast::obj_field[]] fields =
-        parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
+        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                        parse_obj_field, p);
     let (@ast::method)[] meths = ~[];
     let option::t[@ast::method] dtor = none;
@@ -2110,7 +2073,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item {
                     case (token::LPAREN) {
                         auto arg_tys =
                             parse_seq(token::LPAREN, token::RPAREN,
-                                      some(token::COMMA), parse_ty, p);
+                                           some(token::COMMA), parse_ty, p);
                         for (@ast::ty ty in arg_tys.node) {
                             args += ~[rec(ty=ty, id=p.get_id())];
                         }
@@ -2284,8 +2247,8 @@ fn parse_meta_item(&parser p) -> @ast::meta_item {
 }
 
 fn parse_meta_seq(&parser p) -> (@ast::meta_item)[] {
-    ret parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
-                       parse_meta_item, p).node;
+    ret parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
+                  parse_meta_item, p).node;
 }
 
 fn parse_optional_meta(&parser p) -> (@ast::meta_item)[] {
@@ -2424,7 +2387,7 @@ fn parse_crate_from_source_str(&str name, &str source, &ast::crate_cfg cfg,
     auto sess = @rec(cm=cm, mutable next_id=0);
     auto ftype = SOURCE_FILE;
     auto filemap = codemap::new_filemap(name, 0u);
-    sess.cm.files += [filemap];
+    sess.cm.files += ~[filemap];
     auto itr = @interner::mk(str::hash, str::eq);
     auto rdr = lexer::new_reader(sess.cm, source, filemap, itr);
     auto p = new_parser(sess, cfg, rdr, ftype);
@@ -2548,15 +2511,14 @@ fn parse_crate_from_crate_file(&str input, &ast::crate_cfg cfg,
     auto crate_attrs = leading_attrs._0;
     auto first_cdir_attr = leading_attrs._1;
     auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
-    let vec[str] deps = [];
+    let str[] deps = ~[];
     auto cx = @rec(p=p,
                    mode=eval::mode_parse,
                    mutable deps=deps,
                    sess=sess,
                    mutable chpos=p.get_chpos(),
                    cfg = p.get_cfg());
-    auto m =
-        eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
+    auto m = eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
     auto hi = p.get_hi_pos();
     expect(p, token::EOF);
     ret @spanned(lo, hi, rec(directives=cdirs,
diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index 7ac10f6bcf0..21a9bfa6b19 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -1,6 +1,6 @@
 
 import std::ioivec;
-import std::vec;
+import std::ivec;
 import std::str;
 
 
@@ -74,10 +74,10 @@ fn tok_str(token t) -> str {
     }
 }
 
-fn buf_str(vec[mutable token] toks, vec[mutable int] szs, uint left,
-           uint right, uint lim) -> str {
-    auto n = vec::len(toks);
-    assert (n == vec::len(szs));
+fn buf_str(&token[mutable] toks, &int[mutable] szs, uint left, uint right,
+           uint lim) -> str {
+    auto n = ivec::len(toks);
+    assert (n == ivec::len(szs));
     auto i = left;
     auto L = lim;
     auto s = "[";
@@ -104,10 +104,10 @@ fn mk_printer(ioivec::writer out, uint linewidth) -> printer {
 
     let uint n = 3u * linewidth;
     log #fmt("mk_printer %u", linewidth);
-    let vec[mutable token] token = vec::init_elt_mut(EOF, n);
-    let vec[mutable int] size = vec::init_elt_mut(0, n);
-    let vec[mutable uint] scan_stack = vec::init_elt_mut(0u, n);
-    let vec[print_stack_elt] print_stack = [];
+    let token[mutable] token = ivec::init_elt_mut(EOF, n);
+    let int[mutable] size = ivec::init_elt_mut(0, n);
+    let uint[mutable] scan_stack = ivec::init_elt_mut(0u, n);
+    let print_stack_elt[] print_stack = ~[];
     ret printer(out, n, linewidth as int, // margin
                  linewidth as int, // space
                  0u, // left
@@ -208,9 +208,9 @@ obj printer(ioivec::writer out,
 
             mutable uint right, // index of right side of input stream
 
-            mutable vec[mutable token] token,
+            mutable token[mutable] token,
              // ring-buffr stream goes through
-            mutable vec[mutable int] size, // ring-buffer of calculated sizes
+            mutable int[mutable] size, // ring-buffer of calculated sizes
 
             mutable int left_total, // running size of stream "...left"
 
@@ -222,7 +222,7 @@ obj printer(ioivec::writer out,
              // BEGIN (if there is any) on top of it. Stuff is flushed off the
              // bottom as it becomes irrelevant due to the primary ring-buffer
              // advancing.
-             mutable vec[mutable uint] scan_stack,
+             mutable uint[mutable] scan_stack,
             mutable bool scan_stack_empty, // top==bottom disambiguator
 
             mutable uint top, // index of top of scan_stack
@@ -230,7 +230,7 @@ obj printer(ioivec::writer out,
             mutable uint bottom, // index of bottom of scan_stack
 
              // stack of blocks-in-progress being flushed by print
-            mutable vec[print_stack_elt] print_stack,
+            mutable print_stack_elt[] print_stack,
 
             // buffered indentation to avoid writing trailing whitespace
             mutable int pending_indentation) {
@@ -403,7 +403,7 @@ obj printer(ioivec::writer out,
         pending_indentation += amount;
     }
     fn top() -> print_stack_elt {
-        auto n = vec::len(print_stack);
+        auto n = ivec::len(print_stack);
         let print_stack_elt top = rec(offset=0, pbreak=broken(inconsistent));
         if (n != 0u) { top = print_stack.(n - 1u); }
         ret top;
@@ -425,17 +425,17 @@ obj printer(ioivec::writer out,
                     auto col = margin - space + b.offset;
                     log #fmt("print BEGIN -> push broken block at col %d",
                              col);
-                    vec::push(print_stack,
-                              rec(offset=col, pbreak=broken(b.breaks)));
+                    print_stack += ~[rec(offset=col,
+                                         pbreak=broken(b.breaks))];
                 } else {
                     log "print BEGIN -> push fitting block";
-                    vec::push(print_stack, rec(offset=0, pbreak=fits));
+                    print_stack += ~[rec(offset=0, pbreak=fits)];
                 }
             }
             case (END) {
                 log "print END -> pop END";
-                assert (vec::len(print_stack) != 0u);
-                vec::pop(print_stack);
+                assert (ivec::len(print_stack) != 0u);
+                ivec::pop(print_stack);
             }
             case (BREAK(?b)) {
                 auto top = self.top();
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index dd3d98fb45b..8ade4ff6a02 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -4,7 +4,6 @@ import std::int;
 import std::ioivec;
 import std::str;
 import std::uint;
-import std::vec;
 import std::option;
 import parse::lexer;
 import syntax::codemap::codemap;
@@ -1267,7 +1266,7 @@ fn print_view_item(&ps s, &@ast::view_item item) {
 // FIXME: The fact that this builds up the table anew for every call is
 // not good. Eventually, table should be a const.
 fn operator_prec(ast::binop op) -> int {
-    for (parse::parser::op_spec spec in parse::parser::prec_table()) {
+    for (parse::parser::op_spec spec in *parse::parser::prec_table()) {
         if (spec.op == op) { ret spec.prec; }
     }
     fail;
@@ -1445,7 +1444,7 @@ fn maybe_print_comment(&ps s, uint pos) {
 fn print_comment(&ps s, lexer::cmnt cmnt) {
     alt (cmnt.style) {
         case (lexer::mixed) {
-            assert (vec::len(cmnt.lines) == 1u);
+            assert (ivec::len(cmnt.lines) == 1u);
             zerobreak(s.s);
             word(s.s, cmnt.lines.(0));
             zerobreak(s.s);
@@ -1456,7 +1455,7 @@ fn print_comment(&ps s, lexer::cmnt cmnt) {
         }
         case (lexer::trailing) {
             word(s.s, " ");
-            if (vec::len(cmnt.lines) == 1u) {
+            if (ivec::len(cmnt.lines) == 1u) {
                 word(s.s, cmnt.lines.(0));
                 hardbreak(s.s);
             } else {