rustc: Remove a bunch of exterior vectors

Author: pcwalton

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

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:

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];

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,

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)) {

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);
 }

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;
 }