rustc: Remove a bunch of exterior vectors

6 files changed, 108 insertions, 147 deletions

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 {