---

yaml
---
r: 3677
b: refs/heads/master
c: 0e2fff5
h: refs/heads/master
i:
  3675: 9fa4d50
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: bbcbaa6601a56c543f9200ce3bc047c366eff3ed
+refs/heads/master: 0e2fff53375eba748b6d6727f69a2560f96bc8ec

trunk/src/comp/front/config.rs

@@ -82,8 +82,8 @@ fn filter_stmt(&ast::crate_cfg cfg,
 fn fold_block(&ast::crate_cfg cfg, &ast::block_ b,
               fold::ast_fold fld) -> ast::block_  {
     auto filter = bind filter_stmt(cfg, _);
-    auto filtered_stmts = vec::filter_map(filter, b.stmts);
-    ret rec(stmts=vec::map(fld.fold_stmt, filtered_stmts),
+    auto filtered_stmts = ivec::filter_map(filter, b.stmts);
+    ret rec(stmts=ivec::map(fld.fold_stmt, filtered_stmts),
             expr=option::map(fld.fold_expr, b.expr),
             id=b.id);
 }

trunk/src/comp/front/test.rs

@@ -71,14 +71,14 @@ fn mk_main(&test_ctxt cx) -> @ast::item {
     auto ret_ty = @rec(node=ast::ty_nil,
                        span=rec(lo=0u, hi=0u));
 
-    let ast::fn_decl decl = rec(inputs = [],
+    let ast::fn_decl decl = rec(inputs = ~[],
                                 output = ret_ty,
                                 purity = ast::impure_fn,
                                 cf = ast::return,
                                 constraints = ~[]);
     auto proto = ast::proto_fn;
 
-    let ast::block_ body_ = rec(stmts = [],
+    let ast::block_ body_ = rec(stmts = ~[],
                                  expr = option::none,
                                  id = cx.next_node_id());
     auto body = rec(node = body_, span = rec(lo=0u, hi=0u));
@@ -87,7 +87,7 @@ fn mk_main(&test_ctxt cx) -> @ast::item {
                    proto = proto,
                    body = body);
 
-    auto item_ = ast::item_fn(fn_, []);
+    auto item_ = ast::item_fn(fn_, ~[]);
     let ast::item item = rec(ident = "main",
                              attrs = ~[],
                              id = cx.next_node_id(),

trunk/src/comp/metadata/encoder.rs

@@ -1,5 +1,6 @@
 // Metadata encoding
 
+import std::ivec;
 import std::str;
 import std::vec;
 import std::uint;
@@ -33,7 +34,7 @@ fn encode_def_id(&ebml::writer ebml_w, &def_id id) {
     ebml::end_tag(ebml_w);
 }
 
-fn encode_tag_variant_paths(&ebml::writer ebml_w, &vec[variant] variants,
+fn encode_tag_variant_paths(&ebml::writer ebml_w, &variant[] variants,
                             &vec[str] path,
                             &mutable vec[tup(str, uint)] index) {
     for (variant variant in variants) {
@@ -164,9 +165,9 @@ fn encode_kind(&ebml::writer ebml_w, u8 c) {
 
 fn def_to_str(&def_id did) -> str { ret #fmt("%d:%d", did._0, did._1); }
 
-fn encode_type_param_count(&ebml::writer ebml_w, &vec[ty_param] tps) {
+fn encode_type_param_count(&ebml::writer ebml_w, &ty_param[] tps) {
     ebml::start_tag(ebml_w, tag_items_data_item_ty_param_count);
-    ebml::write_vint(ebml_w.writer, vec::len[ty_param](tps));
+    ebml::write_vint(ebml_w.writer, ivec::len[ty_param](tps));
     ebml::end_tag(ebml_w);
 }
 
@@ -207,9 +208,9 @@ fn encode_tag_id(&ebml::writer ebml_w, &def_id id) {
 }
 
 fn encode_tag_variant_info(&@crate_ctxt cx, &ebml::writer ebml_w,
-                           node_id id, &vec[variant] variants,
+                           node_id id, &variant[] variants,
                            &mutable vec[tup(int, uint)] index,
-                           &vec[ty_param] ty_params) {
+                           &ty_param[] ty_params) {
     for (variant variant in variants) {
         index += [tup(variant.node.id, ebml_w.writer.tell())];
         ebml::start_tag(ebml_w, tag_items_data_item);

trunk/src/comp/middle/alias.rs

@@ -53,7 +53,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
     tcx.sess.abort_if_errors();
 }
 
-fn visit_fn(@ctx cx, &ast::_fn f, &vec[ast::ty_param] tp, &span sp,
+fn visit_fn(@ctx cx, &ast::_fn f, &ast::ty_param[] tp, &span sp,
             &fn_ident name, ast::node_id id, &scope sc, &vt[scope] v) {
     visit::visit_fn_decl(f.decl, sc, v);
     for (ast::arg arg_ in f.decl.inputs) {
@@ -132,7 +132,7 @@ fn visit_expr(@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) {
     if (!handled) { visit::visit_expr(ex, sc, v); }
 }
 
-fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
+fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) ->
    rec(vec[node_id] root_vars, vec[ty::t] unsafe_ts) {
     auto fty = ty::expr_ty(*cx.tcx, f);
     auto arg_ts = fty_args(cx, fty);
@@ -261,7 +261,7 @@ fn check_tail_call(&ctx cx, &@ast::expr call) {
     }
 }
 
-fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms, &scope sc,
+fn check_alt(&ctx cx, &@ast::expr input, &ast::arm[] arms, &scope sc,
              &vt[scope] v) {
     visit::visit_expr(input, sc, v);
     auto root = expr_root(cx, input, true);

trunk/src/comp/middle/resolve.rs

@@ -47,7 +47,7 @@ export crate_map;
 tag scope {
     scope_crate(@ast::crate);
     scope_item(@ast::item);
-    scope_fn(ast::fn_decl, vec[ast::ty_param]);
+    scope_fn(ast::fn_decl, ast::ty_param[]);
     scope_native_item(@ast::native_item);
     scope_loop(@ast::local); // there's only 1 decl per loop.
     scope_block(ast::block);
@@ -346,7 +346,7 @@ fn visit_native_item_with_scope(&@ast::native_item ni, &scopes sc,
     visit::visit_native_item(ni, cons(scope_native_item(ni), @sc), v);
 }
 
-fn visit_fn_with_scope(&@env e, &ast::_fn f, &vec[ast::ty_param] tp, &span sp,
+fn visit_fn_with_scope(&@env e, &ast::_fn f, &ast::ty_param[] tp, &span sp,
                        &fn_ident name, node_id id, &scopes sc,
                        &vt[scopes] v) {
     // here's where we need to set up the mapping
@@ -376,7 +376,7 @@ fn visit_expr_with_scope(&@ast::expr x, &scopes sc, &vt[scopes] v) {
             case (ast::expr_for_each(?d, _, _)) {
                 cons[scope](scope_loop(d), @sc)
             }
-            case (ast::expr_fn(?f)) { cons(scope_fn(f.decl, []), @sc) }
+            case (ast::expr_fn(?f)) { cons(scope_fn(f.decl, ~[]), @sc) }
             case (_) { sc }
         };
     visit::visit_expr(x, new_sc, v);
@@ -638,8 +638,7 @@ fn lookup_in_scope(&env e, scopes sc, &span sp, &ident name, namespace ns) ->
             }
             case (scope_native_item(?it)) {
                 alt (it.node) {
-                    case (ast::native_item_fn(_, ?decl, ?ty_params))
-                         {
+                    case (ast::native_item_fn(_, ?decl, ?ty_params)) {
                         ret lookup_in_fn(name, decl, ty_params, ns);
                     }
                 }
@@ -690,7 +689,7 @@ fn lookup_in_scope(&env e, scopes sc, &span sp, &ident name, namespace ns) ->
 
 }
 
-fn lookup_in_ty_params(&ident name, &vec[ast::ty_param] ty_params) ->
+fn lookup_in_ty_params(&ident name, &ast::ty_param[] ty_params) ->
    option::t[def] {
     auto i = 0u;
     for (ast::ty_param tp in ty_params) {
@@ -720,7 +719,7 @@ fn lookup_in_pat(&ident name, &ast::pat pat) -> option::t[def] {
 }
 
 fn lookup_in_fn(&ident name, &ast::fn_decl decl,
-                &vec[ast::ty_param] ty_params,
+                &ast::ty_param[] ty_params,
                 namespace ns) -> option::t[def] {
     alt (ns) {
         case (ns_value) {
@@ -736,7 +735,7 @@ fn lookup_in_fn(&ident name, &ast::fn_decl decl,
     }
 }
 
-fn lookup_in_obj(&ident name, &ast::_obj ob, &vec[ast::ty_param] ty_params,
+fn lookup_in_obj(&ident name, &ast::_obj ob, &ast::ty_param[] ty_params,
                  namespace ns) -> option::t[def] {
     alt (ns) {
         case (ns_value) {
@@ -1229,18 +1228,22 @@ fn check_item(@env e, &@ast::item i, &() x, &vt[()] v) {
     alt (i.node) {
         case (ast::item_fn(?f, ?ty_params)) {
             check_fn(*e, i.span, f);
-            ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
+            ensure_unique_ivec(*e, i.span, ty_params, ident_id,
+                               "type parameter");
         }
         case (ast::item_obj(?ob, ?ty_params, _)) {
             fn field_name(&ast::obj_field field) -> ident { ret field.ident; }
-            ensure_unique(*e, i.span, ob.fields, field_name, "object field");
+            ensure_unique_ivec(*e, i.span, ob.fields, field_name,
+                               "object field");
             for (@ast::method m in ob.methods) {
                 check_fn(*e, m.span, m.node.meth);
             }
-            ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
+            ensure_unique_ivec(*e, i.span, ty_params, ident_id,
+                               "type parameter");
         }
         case (ast::item_tag(_, ?ty_params)) {
-            ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
+            ensure_unique_ivec(*e, i.span, ty_params, ident_id,
+                               "type parameter");
         }
         case (_) { }
     }
@@ -1315,7 +1318,7 @@ fn check_block(@env e, &ast::block b, &() x, &vt[()] v) {
 
 fn check_fn(&env e, &span sp, &ast::_fn f) {
     fn arg_name(&ast::arg a) -> ident { ret a.ident; }
-    ensure_unique(e, sp, f.decl.inputs, arg_name, "argument");
+    ensure_unique_ivec(e, sp, f.decl.inputs, arg_name, "argument");
 }
 
 type checker = @rec(mutable vec[ident] seen, str kind, session sess);
@@ -1341,6 +1344,14 @@ fn ensure_unique[T](&env e, &span sp, &vec[T] elts, fn(&T) -> ident  id,
     auto ch = checker(e, kind);
     for (T elt in elts) { add_name(ch, sp, id(elt)); }
 }
+
+// FIXME: Remove me.
+fn ensure_unique_ivec[T](&env e, &span sp, &T[] elts, fn(&T) -> ident  id,
+                         &str kind) {
+    auto ch = checker(e, kind);
+    for (T elt in elts) { add_name(ch, sp, id(elt)); }
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;