Rewrite bitv to use classes and optimize its representation

Rewrote bitv as a class that uses a 32-bit int as its representation
for bit vectors of 32 bits or less, and a vector (the old representation)
otherwise. I didn't benchmark very much, but a bit of informal benchmarking
suggested this is a win.

Closes #2341

Author: catamorphism

src/libstd/bitv.rs

@@ -29,7 +29,7 @@ updating the states using rule (2) until there are no changes.
 
 import dvec::extensions;
 
-import std::bitv::{bitv, methods};
+import std::bitv::{bitv};
 
 import proto::methods;
 import ast_builder::empty_span;
@@ -38,7 +38,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
     #debug("initializing colive analysis");
     let num_states = proto.num_states();
     let colive = do (copy proto.states).map_to_vec |state| {
-        let bv = bitv(num_states, false);
+        let bv = ~bitv(num_states, false);
         for state.reachable |s| {
             bv.set(s.id, true);
         }

src/libsyntax/ext/pipes/liveness.rs

@@ -53,8 +53,8 @@ fn empty_poststate(num_vars: uint) -> poststate {
 
 fn false_postcond(num_vars: uint) -> postcond {
     let rslt = create_tritv(num_vars);
-    tritv_set_all(rslt);
-    ret rslt;
+    rslt.set_all();
+    rslt
 }
 
 fn empty_pre_post(num_vars: uint) -> pre_and_post {
@@ -76,15 +76,11 @@ fn get_pre(&&p: pre_and_post) -> precond { ret p.precondition; }
 
 fn get_post(&&p: pre_and_post) -> postcond { ret p.postcondition; }
 
-fn difference(p1: precond, p2: precond) -> bool {
-    ret tritv_difference(p1, p2);
-}
+fn difference(p1: precond, p2: precond) -> bool { p1.difference(p2) }
 
-fn union(p1: precond, p2: precond) -> bool { ret tritv_union(p1, p2); }
+fn union(p1: precond, p2: precond) -> bool { p1.union(p2) }
 
-fn intersect(p1: precond, p2: precond) -> bool {
-    ret tritv_intersect(p1, p2);
-}
+fn intersect(p1: precond, p2: precond) -> bool { p1.intersect(p2) }
 
 fn pps_len(p: pre_and_post) -> uint {
     // gratuitous check
@@ -95,13 +91,13 @@ fn pps_len(p: pre_and_post) -> uint {
 
 fn require(i: uint, p: pre_and_post) {
     // sets the ith bit in p's pre
-    tritv_set(i, p.precondition, ttrue);
+    p.precondition.set(i, ttrue);
 }
 
 fn require_and_preserve(i: uint, p: pre_and_post) {
     // sets the ith bit in p's pre and post
-    tritv_set(i, p.precondition, ttrue);
-    tritv_set(i, p.postcondition, ttrue);
+    p.precondition.set(i, ttrue);
+    p.postcondition.set(i, ttrue);
 }
 
 fn set_in_postcond(i: uint, p: pre_and_post) -> bool {
@@ -110,8 +106,8 @@ fn set_in_postcond(i: uint, p: pre_and_post) -> bool {
 }
 
 fn set_in_postcond_(i: uint, p: postcond) -> bool {
-    let was_set = tritv_get(p, i);
-    tritv_set(i, p, ttrue);
+    let was_set = p.get(i);
+    p.set(i, ttrue);
     ret was_set != ttrue;
 }
 
@@ -121,8 +117,8 @@ fn set_in_poststate(i: uint, s: pre_and_post_state) -> bool {
 }
 
 fn set_in_poststate_(i: uint, p: poststate) -> bool {
-    let was_set = tritv_get(p, i);
-    tritv_set(i, p, ttrue);
+    let was_set = p.get(i);
+    p.set(i, ttrue);
     ret was_set != ttrue;
 
 }
@@ -133,8 +129,8 @@ fn clear_in_poststate(i: uint, s: pre_and_post_state) -> bool {
 }
 
 fn clear_in_poststate_(i: uint, s: poststate) -> bool {
-    let was_set = tritv_get(s, i);
-    tritv_set(i, s, tfalse);
+    let was_set = s.get(i);
+    s.set(i, tfalse);
     ret was_set != tfalse;
 }
 
@@ -144,61 +140,61 @@ fn clear_in_prestate(i: uint, s: pre_and_post_state) -> bool {
 }
 
 fn clear_in_prestate_(i: uint, s: prestate) -> bool {
-    let was_set = tritv_get(s, i);
-    tritv_set(i, s, tfalse);
+    let was_set = s.get(i);
+    s.set(i, tfalse);
     ret was_set != tfalse;
 }
 
 fn clear_in_postcond(i: uint, s: pre_and_post) -> bool {
     // sets the ith bit in p's post
-    let was_set = tritv_get(s.postcondition, i);
-    tritv_set(i, s.postcondition, tfalse);
+    let was_set = s.postcondition.get(i);
+    s.postcondition.set(i, tfalse);
     ret was_set != tfalse;
 }
 
 // Sets all the bits in a's precondition to equal the
 // corresponding bit in p's precondition.
 fn set_precondition(a: ts_ann, p: precond) {
-    tritv_copy(a.conditions.precondition, p);
+    a.conditions.precondition.become(p);
 }
 
 
 // Sets all the bits in a's postcondition to equal the
 // corresponding bit in p's postcondition.
 fn set_postcondition(a: ts_ann, p: postcond) {
-    tritv_copy(a.conditions.postcondition, p);
+    a.conditions.postcondition.become(p);
 }
 
 
 // Sets all the bits in a's prestate to equal the
 // corresponding bit in p's prestate.
 fn set_prestate(a: ts_ann, p: prestate) -> bool {
-    ret tritv_copy(a.states.prestate, p);
+    a.states.prestate.become(p)
 }
 
 
 // Sets all the bits in a's postcondition to equal the
 // corresponding bit in p's postcondition.
 fn set_poststate(a: ts_ann, p: poststate) -> bool {
-    ret tritv_copy(a.states.poststate, p);
+    a.states.poststate.become(p)
 }
 
 
 // Set all the bits in p that are set in new
 fn extend_prestate(p: prestate, newv: poststate) -> bool {
-    ret tritv_union(p, newv);
+    p.union(newv)
 }
 
 
 // Set all the bits in p that are set in new
 fn extend_poststate(p: poststate, newv: poststate) -> bool {
-    ret tritv_union(p, newv);
+    p.union(newv)
 }
 
 // Sets the given bit in p to "don't care"
 fn relax_prestate(i: uint, p: prestate) -> bool {
-    let was_set = tritv_get(p, i);
-    tritv_set(i, p, dont_care);
+    let was_set = p.get(i);
+    p.set(i, dont_care);
     ret was_set != dont_care;
 }
 
@@ -211,10 +207,10 @@ fn relax_poststate(i: uint, p: poststate) -> bool {
 fn relax_precond(i: uint, p: precond) { relax_prestate(i, p); }
 
 // Sets all the bits in p to "don't care"
-fn clear(p: precond) { tritv_clear(p); }
+fn clear(p: precond) { p.clear(); }
 
 // Sets all the bits in p to true
-fn set(p: precond) { tritv_set_all(p); }
+fn set(p: precond) { p.set_all(); }
 
 fn ann_precond(a: ts_ann) -> precond { ret a.conditions.precondition; }
 
@@ -227,16 +223,16 @@ fn pp_clone(p: pre_and_post) -> pre_and_post {
          postcondition: clone(p.postcondition)};
 }
 
-fn clone(p: prestate) -> prestate { ret tritv_clone(p); }
+fn clone(p: prestate) -> prestate { p.clone() }
 
 
 // returns true if a implies b
 // that is, returns true except if for some bits c and d,
 // c = 1 and d = either 0 or "don't know"
 fn implies(a: t, b: t) -> bool {
-    let tmp = tritv_clone(b);
-    tritv_difference(tmp, a);
-    ret tritv_doesntcare(tmp);
+    let tmp = b.clone();
+    tmp.difference(a);
+    tmp.doesntcare()
 }
 
 fn trit_str(t: trit) -> ~str {

src/rustc/middle/tstate/ann.rs

@@ -15,7 +15,7 @@ import tstate::ann::{pre_and_post, pre_and_post_state, empty_ann, prestate,
                      clear_in_poststate_};
 import driver::session::session;
 import dvec::{dvec, extensions};
-import tritv::{dont_care, tfalse, tritv_get, ttrue};
+import tritv::{trit, tfalse, ttrue, dont_care, t};
 
 import syntax::print::pprust::{constr_args_to_str, lit_to_str};
 
@@ -59,7 +59,7 @@ fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> ~str {
     let mut s = ~"";
     let mut comma = false;
     for constraints(fcx).each |p| {
-        alt tritv_get(v, p.bit_num) {
+        alt v.get(p.bit_num) {
           dont_care { }
           tt {
             s +=
@@ -80,8 +80,8 @@ fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t)
    -> ~str {
     let mut s = ~"";
     for constraints(fcx).each |c| {
-        if tritv_get(expected, c.bit_num) == ttrue &&
-               tritv_get(actual, c.bit_num) != ttrue {
+      if expected.get(c.bit_num) == ttrue &&
+         actual.get(c.bit_num) != ttrue {
             s = constraint_to_str(fcx.ccx.tcx, c.c);
             break;
         }
@@ -108,35 +108,35 @@ fn log_cond(v: ~[uint]) { log(debug, tos(v)); }
 fn log_cond_err(v: ~[uint]) { log(error, tos(v)); }
 
 fn log_pp(pp: pre_and_post) {
-    let p1 = tritv::to_vec(pp.precondition);
-    let p2 = tritv::to_vec(pp.postcondition);
+    let p1 = pp.precondition.to_vec();
+    let p2 = pp.postcondition.to_vec();
     #debug("pre:");
     log_cond(p1);
     #debug("post:");
     log_cond(p2);
 }
 
 fn log_pp_err(pp: pre_and_post) {
-    let p1 = tritv::to_vec(pp.precondition);
-    let p2 = tritv::to_vec(pp.postcondition);
+    let p1 = pp.precondition.to_vec();
+    let p2 = pp.postcondition.to_vec();
     #error("pre:");
     log_cond_err(p1);
     #error("post:");
     log_cond_err(p2);
 }
 
 fn log_states(pp: pre_and_post_state) {
-    let p1 = tritv::to_vec(pp.prestate);
-    let p2 = tritv::to_vec(pp.poststate);
+    let p1 = pp.prestate.to_vec();
+    let p2 = pp.poststate.to_vec();
     #debug("prestate:");
     log_cond(p1);
     #debug("poststate:");
     log_cond(p2);
 }
 
 fn log_states_err(pp: pre_and_post_state) {
-    let p1 = tritv::to_vec(pp.prestate);
-    let p2 = tritv::to_vec(pp.poststate);
+    let p1 = pp.prestate.to_vec();
+    let p2 = pp.poststate.to_vec();
     #error("prestate:");
     log_cond_err(p1);
     #error("poststate:");

src/rustc/middle/tstate/auxiliary.rs

@@ -184,7 +184,7 @@ fn handle_update(fcx: fn_ctxt, parent: @expr, lhs: @expr, rhs: @expr,
     alt lhs.node {
       expr_path(p) {
         let post = expr_postcond(fcx.ccx, parent);
-        let tmp = tritv_clone(post);
+        let tmp = post.clone();
 
         alt ty {
           oper_move {
@@ -497,7 +497,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                     /* Clear out anything that the previous initializer
                     guaranteed */
                     let e_pp = expr_pp(fcx.ccx, an_init.expr);
-                    tritv_copy(prev_pp.precondition,
+                    prev_pp.precondition.become(
                                seq_preconds(fcx, ~[prev_pp, e_pp]));
 
                     /* Include the LHSs too, since those aren't in the