---

yaml
---
r: 3711
b: refs/heads/master
c: e1b107d
h: refs/heads/master
i:
  3709: bb7cd28
  3707: 63590ab
  3703: 42affa0
  3695: f96bf13
  3679: 24cf6a7
  3647: 7f9f5ce
  3583: c282e5e
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 3958c72cd8c899bfc77a56ad859e31e13615c1c5
+refs/heads/master: e1b107d74ef5c27ec4c000f1fe4a9f55a7c67b97

trunk/src/comp/front/config.rs

@@ -36,9 +36,9 @@ fn filter_item(&ast::crate_cfg cfg,
 fn fold_mod(&ast::crate_cfg cfg, &ast::_mod m,
               fold::ast_fold fld) -> ast::_mod {
     auto filter = bind filter_item(cfg, _);
-    auto filtered_items = vec::filter_map(filter, m.items);
-    ret rec(view_items=vec::map(fld.fold_view_item, m.view_items),
-            items=vec::map(fld.fold_item, filtered_items));
+    auto filtered_items = ivec::filter_map(filter, m.items);
+    ret rec(view_items=ivec::map(fld.fold_view_item, m.view_items),
+            items=ivec::map(fld.fold_item, filtered_items));
 }
 
 fn filter_native_item(&ast::crate_cfg cfg, &@ast::native_item item)
@@ -53,10 +53,10 @@ fn filter_native_item(&ast::crate_cfg cfg, &@ast::native_item item)
 fn fold_native_mod(&ast::crate_cfg cfg, &ast::native_mod nm,
                    fold::ast_fold fld) -> ast::native_mod {
     auto filter = bind filter_native_item(cfg, _);
-    auto filtered_items = vec::filter_map(filter, nm.items);
+    auto filtered_items = ivec::filter_map(filter, nm.items);
     ret rec(native_name=nm.native_name,
             abi=nm.abi,
-            view_items=vec::map(fld.fold_view_item, nm.view_items),
+            view_items=ivec::map(fld.fold_view_item, nm.view_items),
             items=filtered_items);
 }
 

trunk/src/comp/front/test.rs

@@ -50,14 +50,12 @@ fn fold_crate(&test_ctxt cx, &ast::crate_ c,
 
 fn add_test_module(&test_ctxt cx, &ast::_mod m) -> ast::_mod {
     auto testmod = mk_test_module(cx);
-    ret rec(items = m.items + [testmod]
-            with m);
+    ret rec(items=m.items + ~[testmod] with m);
 }
 
 fn mk_test_module(&test_ctxt cx) -> @ast::item {
     auto mainfn = mk_main(cx);
-    let ast::_mod testmod = rec(view_items = [],
-                                items = [mainfn]);
+    let ast::_mod testmod = rec(view_items=~[], items=~[mainfn]);
     auto item_ = ast::item_mod(testmod);
     let ast::item item = rec(ident = "__test",
                              attrs = ~[],

trunk/src/comp/metadata/encoder.rs

@@ -216,7 +216,7 @@ fn encode_tag_variant_info(&@crate_ctxt cx, &ebml::writer ebml_w,
         encode_kind(ebml_w, 'v' as u8);
         encode_tag_id(ebml_w, local_def(id));
         encode_type(cx, ebml_w, node_id_to_monotype(cx.tcx, variant.node.id));
-        if (vec::len[variant_arg](variant.node.args) > 0u) {
+        if (ivec::len[variant_arg](variant.node.args) > 0u) {
             encode_symbol(cx, ebml_w, variant.node.id);
         }
         encode_discriminant(cx, ebml_w, variant.node.id);

trunk/src/comp/middle/resolve.rs

@@ -382,25 +382,23 @@ fn visit_expr_with_scope(&@ast::expr x, &scopes sc, &vt[scopes] v) {
     visit::visit_expr(x, new_sc, v);
 }
 
-fn follow_import(&env e, &scopes sc,
-                 vec[ident] path, &span sp) -> option::t[def] {
-    auto path_len = vec::len(path);
+fn follow_import(&env e, &scopes sc, &ident[] path, &span sp)
+        -> option::t[def] {
+    auto path_len = ivec::len(path);
     auto dcur = lookup_in_scope_strict(e, sc, sp, path.(0), ns_module);
     auto i = 1u;
     while (true && option::is_some(dcur)) {
         if (i == path_len) { break; }
-        dcur =
-            lookup_in_mod_strict(e, option::get(dcur),
-                                 sp, path.(i), ns_module, outside);
+        dcur = lookup_in_mod_strict(e, option::get(dcur),
+                                    sp, path.(i), ns_module, outside);
         i += 1u;
     }
     if (i == path_len) {
         alt (option::get(dcur)) {
             case (ast::def_mod(?def_id)) { ret dcur; }
             case (ast::def_native_mod(?def_id)) { ret dcur; }
             case (_) {
-                e.sess.span_err(sp,
-                                str::connect(path, "::") +
+                e.sess.span_err(sp, str::connect_ivec(path, "::") +
                                 " does not name a module.");
                 ret none;
             }
@@ -457,7 +455,7 @@ fn resolve_import(&env e, &@ast::view_item it, &scopes sc) {
         }
     }
     e.imports.insert(defid._1, resolving(it.span));
-    auto n_idents = vec::len(ids);
+    auto n_idents = ivec::len(ids);
     auto end_id = ids.(n_idents - 1u);
     if (n_idents == 1u) {
         auto next_sc = std::list::cdr(sc);

trunk/src/comp/middle/trans.rs

@@ -8529,7 +8529,7 @@ fn trans_res_ctor(@local_ctxt cx, &span sp, &ast::_fn dtor,
 fn trans_tag_variant(@local_ctxt cx, ast::node_id tag_id,
                      &ast::variant variant, int index, bool is_degen,
                      &ast::ty_param[] ty_params) {
-    if (vec::len[ast::variant_arg](variant.node.args) == 0u) {
+    if (std::ivec::len[ast::variant_arg](variant.node.args) == 0u) {
         ret; // nullary constructors are just constants
 
     }
@@ -9043,7 +9043,7 @@ fn collect_tag_ctor(@crate_ctxt ccx, &@ast::item i, &vec[str] pt,
     alt (i.node) {
         case (ast::item_tag(?variants, ?tps)) {
             for (ast::variant variant in variants) {
-                if (vec::len[ast::variant_arg](variant.node.args) != 0u) {
+                if (std::ivec::len(variant.node.args) != 0u) {
                     decl_fn_and_pair(ccx, i.span,
                                      new_pt + [variant.node.name], "tag", tps,
                                      variant.node.id);

trunk/src/comp/middle/ty.rs

@@ -2830,8 +2830,7 @@ fn tag_variants(&ctxt cx, &ast::def_id id) -> variant_info[] {
                         auto ctor_ty = node_id_to_monotype
                             (cx, variant.node.id);
                         let t[] arg_tys = ~[];
-                        if (vec::len[ast::variant_arg](variant.node.args) >
-                                0u) {
+                        if (std::ivec::len(variant.node.args) > 0u) {
                             for (arg a in ty_fn_args(cx, ctor_ty)) {
                                 arg_tys += ~[a.ty];
                             }

trunk/src/comp/middle/typeck.rs

@@ -692,7 +692,7 @@ mod collect {
             // constructors get turned into functions.
 
             auto result_ty;
-            if (vec::len[ast::variant_arg](variant.node.args) == 0u) {
+            if (ivec::len[ast::variant_arg](variant.node.args) == 0u) {
                 result_ty = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
             } else {
                 // As above, tell ast_ty_to_ty() that trans_ty_item_to_ty()

trunk/src/comp/syntax/ast.rs

@@ -3,7 +3,6 @@
 import std::ivec;
 import std::option;
 import std::str;
-import std::vec;
 import codemap::span;
 import codemap::filename;
 
@@ -481,7 +480,7 @@ type anon_obj =
         // with_obj: the original object being extended, if it exists.
         option::t[@expr] with_obj);
 
-type _mod = rec(vec[@view_item] view_items, vec[@item] items);
+type _mod = rec((@view_item)[] view_items, (@item)[] items);
 
 tag native_abi {
     native_abi_rust;
@@ -493,21 +492,21 @@ tag native_abi {
 type native_mod =
     rec(str native_name,
         native_abi abi,
-        vec[@view_item] view_items,
-        vec[@native_item] items);
+        (@view_item)[] view_items,
+        (@native_item)[] items);
 
 type variant_arg = rec(@ty ty, node_id id);
 
-type variant_ = rec(str name, vec[variant_arg] args, node_id id);
+type variant_ = rec(str name, (variant_arg)[] args, node_id id);
 
 type variant = spanned[variant_];
 
 type view_item = spanned[view_item_];
 
 tag view_item_ {
     view_item_use(ident, (@meta_item)[], node_id);
-    view_item_import(ident, vec[ident], node_id);
-    view_item_import_glob(vec[ident], node_id);
+    view_item_import(ident, ident[], node_id);
+    view_item_import_glob(ident[], node_id);
     view_item_export(ident, node_id);
 }
 

trunk/src/comp/syntax/fold.rs

@@ -463,15 +463,15 @@ fn noop_fold_fn(&_fn f, ast_fold fld) -> _fn {
 
 // ...nor do modules
 fn noop_fold_mod(&_mod m, ast_fold fld) -> _mod {
-    ret rec(view_items=map(fld.fold_view_item, m.view_items),
-            items=map(fld.fold_item, m.items));
+    ret rec(view_items=ivec::map(fld.fold_view_item, m.view_items),
+            items=ivec::map(fld.fold_item, m.items));
 }
 
 fn noop_fold_native_mod(&native_mod nm, ast_fold fld) -> native_mod {
     ret rec(native_name=nm.native_name,
             abi=nm.abi,
-            view_items=map(fld.fold_view_item, nm.view_items),
-            items=map(fld.fold_native_item, nm.items))
+            view_items=ivec::map(fld.fold_view_item, nm.view_items),
+            items=ivec::map(fld.fold_native_item, nm.items))
 }
 
 fn noop_fold_variant(&variant_ v, ast_fold fld) -> variant_ {
@@ -480,7 +480,7 @@ fn noop_fold_variant(&variant_ v, ast_fold fld) -> variant_ {
     }
     auto fold_variant_arg = bind fold_variant_arg_(_,fld);
     ret rec(name=v.name,
-            args=map(fold_variant_arg, v.args),
+            args=ivec::map(fold_variant_arg, v.args),
             id=v.id);
 }
 

trunk/src/comp/syntax/parse/eval.rs

@@ -25,24 +25,24 @@ type ctx =
          ast::crate_cfg cfg);
 
 fn eval_crate_directives(ctx cx, &(@ast::crate_directive)[] cdirs,
-                         str prefix, &mutable vec[@ast::view_item] view_items,
-                         &mutable vec[@ast::item] items) {
+                         str prefix, &mutable (@ast::view_item)[] view_items,
+                         &mutable (@ast::item)[] items) {
     for (@ast::crate_directive sub_cdir in cdirs) {
         eval_crate_directive(cx, sub_cdir, prefix, view_items, items);
     }
 }
 
 fn eval_crate_directives_to_mod(ctx cx, &(@ast::crate_directive)[] cdirs,
                                 str prefix) -> ast::_mod {
-    let vec[@ast::view_item] view_items = [];
-    let vec[@ast::item] items = [];
+    let (@ast::view_item)[] view_items = ~[];
+    let (@ast::item)[] items = ~[];
     eval_crate_directives(cx, cdirs, prefix, view_items, items);
     ret rec(view_items=view_items, items=items);
 }
 
 fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
-                        &mutable vec[@ast::view_item] view_items,
-                        &mutable vec[@ast::item] items) {
+                        &mutable (@ast::view_item)[] view_items,
+                        &mutable (@ast::item)[] items) {
     alt (cdir.node) {
         case (ast::cdir_src_mod(?id, ?file_opt, ?attrs)) {
             auto file_path = id + ".rs";
@@ -68,7 +68,7 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
                  mod_attrs);
             // Thread defids and chpos through the parsers
             cx.chpos = p0.get_chpos();
-            vec::push[@ast::item](items, i);
+            items += ~[i];
         }
         case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs, ?attrs)) {
             auto path = id;
@@ -85,11 +85,9 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
                           node=ast::item_mod(m0),
                           span=cdir.span);
             cx.sess.next_id += 1;
-            vec::push[@ast::item](items, i);
-        }
-        case (ast::cdir_view_item(?vi)) {
-            vec::push[@ast::view_item](view_items, vi);
+            items += ~[i];
         }
+        case (ast::cdir_view_item(?vi)) { view_items += ~[vi]; }
         case (ast::cdir_syntax(?pth)) { }
         case (ast::cdir_auth(?pth, ?eff)) { }
     }

trunk/src/comp/syntax/parse/parser.rs

@@ -1859,15 +1859,15 @@ fn parse_mod_items(&parser p, token::token term,
         parse_view(p)
     } else {
         // Shouldn't be any view items since we've already parsed an item attr
-        []
+        ~[]
     };
-    let vec[@ast::item] items = [];
+    let (@ast::item)[] items = ~[];
     auto initial_attrs = first_item_attrs;
     while (p.peek() != term) {
         auto attrs = initial_attrs + parse_outer_attributes(p);
         initial_attrs = ~[];
         alt (parse_item(p, attrs)) {
-            case (got_item(?i)) { vec::push(items, i); }
+            case (got_item(?i)) { items += ~[i]; }
             case (_) {
                 p.fatal("expected item but found " +
                           token::to_str(p.get_reader(), p.peek()));
@@ -1948,14 +1948,14 @@ fn parse_native_mod_items(&parser p, &str native_name, ast::native_abi abi,
         parse_native_view(p)
     } else {
         // Shouldn't be any view items since we've already parsed an item attr
-        []
+        ~[]
     };
-    let vec[@ast::native_item] items = [];
+    let (@ast::native_item)[] items = ~[];
     auto initial_attrs = first_item_attrs;
     while (p.peek() != token::RBRACE) {
         auto attrs = initial_attrs + parse_outer_attributes(p);
         initial_attrs = ~[];
-        items += [parse_native_item(p, attrs)];
+        items += ~[parse_native_item(p, attrs)];
     }
     ret rec(native_name=native_name,
             abi=abi,
@@ -2028,7 +2028,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item {
         expect(p, token::SEMI);
         auto variant = spanned(ty.span.lo, ty.span.hi,
                                rec(name=id,
-                                   args=[rec(ty=ty, id=p.get_id())],
+                                   args=~[rec(ty=ty, id=p.get_id())],
                                    id=p.get_id()));
         ret mk_item(p, lo, ty.span.hi, id,
                     ast::item_tag(~[variant], ty_params), attrs);
@@ -2041,14 +2041,14 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item {
                 check_bad_word(p);
                 auto vlo = p.get_lo_pos();
                 p.bump();
-                let vec[ast::variant_arg] args = [];
+                let ast::variant_arg[] args = ~[];
                 alt (p.peek()) {
                     case (token::LPAREN) {
                         auto arg_tys =
                             parse_seq(token::LPAREN, token::RPAREN,
                                       some(token::COMMA), parse_ty, p);
                         for (@ast::ty ty in arg_tys.node) {
-                            args += [rec(ty=ty, id=p.get_id())];
+                            args += ~[rec(ty=ty, id=p.get_id())];
                         }
                     }
                     case (_) {/* empty */ }
@@ -2243,7 +2243,7 @@ fn parse_rest_import_name(&parser p, ast::ident first,
                           option::t[ast::ident] def_ident) ->
    @ast::view_item {
     auto lo = p.get_lo_pos();
-    let vec[ast::ident] identifiers = [first];
+    let ast::ident[] identifiers = ~[first];
     let bool glob = false;
     while (true) {
         alt (p.peek()) {
@@ -2255,7 +2255,7 @@ fn parse_rest_import_name(&parser p, ast::ident first,
             case (_) { p.fatal("expecting '::' or ';'"); }
         }
         alt (p.peek()) {
-            case (token::IDENT(_, _)) { identifiers += [parse_ident(p)]; }
+            case (token::IDENT(_, _)) { identifiers += ~[parse_ident(p)]; }
             case (
                  //the lexer can't tell the different kinds of stars apart ) :
                  token::BINOP(token::STAR)) {
@@ -2278,7 +2278,7 @@ fn parse_rest_import_name(&parser p, ast::ident first,
                 import_decl =
                     ast::view_item_import_glob(identifiers, p.get_id());
             } else {
-                auto len = vec::len(identifiers);
+                auto len = ivec::len(identifiers);
                 import_decl =
                     ast::view_item_import(identifiers.(len - 1u), identifiers,
                                           p.get_id());
@@ -2347,15 +2347,15 @@ fn is_view_item(&parser p) -> bool {
     ret false;
 }
 
-fn parse_view(&parser p) -> vec[@ast::view_item] {
-    let vec[@ast::view_item] items = [];
-    while (is_view_item(p)) { items += [parse_view_item(p)]; }
+fn parse_view(&parser p) -> (@ast::view_item)[] {
+    let (@ast::view_item)[] items = ~[];
+    while (is_view_item(p)) { items += ~[parse_view_item(p)]; }
     ret items;
 }
 
-fn parse_native_view(&parser p) -> vec[@ast::view_item] {
-    let vec[@ast::view_item] items = [];
-    while (is_view_item(p)) { items += [parse_view_item(p)]; }
+fn parse_native_view(&parser p) -> (@ast::view_item)[] {
+    let (@ast::view_item)[] items = ~[];
+    while (is_view_item(p)) { items += ~[parse_view_item(p)]; }
     ret items;
 }