port some code to use dvec

src/librustsyntax/parse.rs

@@ -139,7 +139,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
       mut token: tok0.tok,
       mut span: span0,
       mut last_span: span0,
-      mut buffer: [],
+      buffer: dvec::dvec(),
       mut restriction: parser::UNRESTRICTED,
       reader: rdr,
       keywords: token::keyword_table(),

src/librustsyntax/parse/parser.rs

@@ -13,6 +13,7 @@ import attr::{parse_outer_attrs_or_ext,
               parse_outer_attributes,
               parse_optional_meta};
 import common::*;
+import dvec::{dvec, extensions};
 
 export expect;
 export file_type;
@@ -54,7 +55,7 @@ type parser = @{
     mut token: token::token,
     mut span: span,
     mut last_span: span,
-    mut buffer: [{tok: token::token, span: span}],
+    buffer: dvec<{tok: token::token, span: span}>,
     mut restriction: restriction,
     reader: reader,
     keywords: hashmap<str, ()>,
@@ -64,12 +65,12 @@ type parser = @{
 impl parser for parser {
     fn bump() {
         self.last_span = self.span;
-        if vec::len(self.buffer) == 0u {
+        if self.buffer.len() == 0u {
             let next = lexer::next_token(self.reader);
             self.token = next.tok;
             self.span = mk_sp(next.chpos, self.reader.chpos);
         } else {
-            let next = vec::shift(self.buffer);
+            let next = self.buffer.shift();
             self.token = next.tok;
             self.span = next.span;
         }
@@ -79,10 +80,10 @@ impl parser for parser {
         self.span = mk_sp(lo, hi);
     }
     fn look_ahead(distance: uint) -> token::token {
-        while vec::len(self.buffer) < distance {
+        while self.buffer.len() < distance {
             let next = lexer::next_token(self.reader);
             let sp = mk_sp(next.chpos, self.reader.chpos);
-            vec::push(self.buffer, {tok: next.tok, span: sp});
+            self.buffer.push({tok: next.tok, span: sp});
         }
         ret self.buffer[distance - 1u].tok;
     }

src/librustsyntax/print/pp.rs

@@ -1,4 +1,5 @@
 import io::writer_util;
+import dvec::{dvec, extensions};
 
 /*
  * This pretty-printer is a direct reimplementation of Philip Karlton's
@@ -102,7 +103,6 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
     let token: [mut token] = vec::to_mut(vec::from_elem(n, EOF));
     let size: [mut int] = vec::to_mut(vec::from_elem(n, 0));
     let scan_stack: [mut uint] = vec::to_mut(vec::from_elem(n, 0u));
-    let print_stack: [print_stack_elt] = [];
     @{out: out,
       buf_len: n,
       mut margin: linewidth as int,
@@ -117,7 +117,7 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
       mut scan_stack_empty: true,
       mut top: 0u,
       mut bottom: 0u,
-      mut print_stack: print_stack,
+      print_stack: dvec(),
       mut pending_indentation: 0}
 }
 
@@ -221,7 +221,7 @@ type printer = @{
     mut top: uint, // index of top of scan_stack
     mut bottom: uint, // index of bottom of scan_stack
     // stack of blocks-in-progress being flushed by print
-    mut print_stack: [print_stack_elt],
+    print_stack: dvec<print_stack_elt>,
     // buffered indentation to avoid writing trailing whitespace
     mut pending_indentation: int
 };
@@ -398,11 +398,12 @@ impl printer for printer {
         self.pending_indentation += amount;
     }
     fn get_top() -> print_stack_elt {
-        let n = vec::len(self.print_stack);
-        let mut top: print_stack_elt =
-            {offset: 0, pbreak: broken(inconsistent)};
-        if n != 0u { top = self.print_stack[n - 1u]; }
-        ret top;
+        let n = self.print_stack.len();
+        if n != 0u {
+            self.print_stack[n - 1u]
+        } else {
+            {offset: 0, pbreak: broken(inconsistent)}
+        }
     }
     fn write_str(s: str) {
         while self.pending_indentation > 0 {
@@ -420,16 +421,18 @@ impl printer for printer {
             if L > self.space {
                 let col = self.margin - self.space + b.offset;
                 #debug("print BEGIN -> push broken block at col %d", col);
-                self.print_stack += [{offset: col, pbreak: broken(b.breaks)}];
+                self.print_stack.push({offset: col,
+                                       pbreak: broken(b.breaks)});
             } else {
                 #debug("print BEGIN -> push fitting block");
-                self.print_stack += [{offset: 0, pbreak: fits}];
+                self.print_stack.push({offset: 0,
+                                       pbreak: fits});
             }
           }
           END {
             #debug("print END -> pop END");
-            assert (vec::len(self.print_stack) != 0u);
-            vec::pop(self.print_stack);
+            assert (self.print_stack.len() != 0u);
+            self.print_stack.pop();
           }
           BREAK(b) {
             let top = self.get_top();

src/librustsyntax/print/pprust.rs

@@ -7,6 +7,7 @@ import pp::{break_offset, word, printer,
             inconsistent, eof};
 import diagnostic;
 import ast_util::operator_prec;
+import dvec::{dvec, extensions};
 
 // The ps is stored here to prevent recursive type.
 enum ann_node {
@@ -29,22 +30,27 @@ type ps =
       literals: option<[comments::lit]>,
       mut cur_cmnt: uint,
       mut cur_lit: uint,
-      mut boxes: [pp::breaks],
+      boxes: dvec<pp::breaks>,
       ann: pp_ann};
 
-fn ibox(s: ps, u: uint) { s.boxes += [pp::inconsistent]; pp::ibox(s.s, u); }
+fn ibox(s: ps, u: uint) {
+    s.boxes.push(pp::inconsistent);
+    pp::ibox(s.s, u);
+}
 
-fn end(s: ps) { vec::pop(s.boxes); pp::end(s.s); }
+fn end(s: ps) {
+    s.boxes.pop();
+    pp::end(s.s);
+}
 
 fn rust_printer(writer: io::writer) -> ps {
-    let boxes: [pp::breaks] = [];
     ret @{s: pp::mk_printer(writer, default_columns),
           cm: none::<codemap>,
           comments: none::<[comments::cmnt]>,
           literals: none::<[comments::lit]>,
           mut cur_cmnt: 0u,
           mut cur_lit: 0u,
-          mut boxes: boxes,
+          boxes: dvec(),
           ann: no_ann()};
 }
 
@@ -59,7 +65,6 @@ const default_columns: uint = 78u;
 fn print_crate(cm: codemap, span_diagnostic: diagnostic::span_handler,
                crate: @ast::crate, filename: str, in: io::reader,
                out: io::writer, ann: pp_ann) {
-    let boxes: [pp::breaks] = [];
     let r = comments::gather_comments_and_literals(span_diagnostic,
                                                    filename, in);
     let s =
@@ -69,7 +74,7 @@ fn print_crate(cm: codemap, span_diagnostic: diagnostic::span_handler,
           literals: some(r.lits),
           mut cur_cmnt: 0u,
           mut cur_lit: 0u,
-          mut boxes: boxes,
+          boxes: dvec(),
           ann: ann};
     print_crate_(s, crate);
 }
@@ -195,9 +200,15 @@ fn test_variant_to_str() {
     assert varstr == "principle_skinner";
 }
 
-fn cbox(s: ps, u: uint) { s.boxes += [pp::consistent]; pp::cbox(s.s, u); }
+fn cbox(s: ps, u: uint) {
+    s.boxes.push(pp::consistent);
+    pp::cbox(s.s, u);
+}
 
-fn box(s: ps, u: uint, b: pp::breaks) { s.boxes += [b]; pp::box(s.s, u, b); }
+fn box(s: ps, u: uint, b: pp::breaks) {
+    s.boxes.push(b);
+    pp::box(s.s, u, b);
+}
 
 fn nbsp(s: ps) { word(s.s, " "); }
 
@@ -245,7 +256,7 @@ fn is_bol(s: ps) -> bool {
 }
 
 fn in_cbox(s: ps) -> bool {
-    let len = vec::len(s.boxes);
+    let len = s.boxes.len();
     if len == 0u { ret false; }
     ret s.boxes[len - 1u] == pp::consistent;
 }

src/rustc/middle/borrowck.rs

@@ -20,9 +20,12 @@ fn check_crate(tcx: ty::ctxt,
                crate: @ast::crate) -> (root_map, mutbl_map) {
 
     // big hack to keep this off except when I want it on
-    let msg_level = alt os::getenv("RUST_BORROWCK") {
-      none {tcx.sess.opts.borrowck}
-      some(v) {option::get(uint::from_str(v))}
+    let msg_level = if tcx.sess.opts.borrowck != 0u {
+        tcx.sess.opts.borrowck
+    } else {
+        os::getenv("RUST_BORROWCK").map_default(0u) { |v|
+            option::get(uint::from_str(v))
+        }
     };
 
     let bccx = @{tcx: tcx,