rustc: Do less work still in typestate

Author: brson

src/rustc/middle/tstate/auxiliary.rs

@@ -224,7 +224,8 @@ type fn_info =
     {constrs: constr_map,
      num_constraints: uint,
      cf: ret_style,
-     used_vars: @mut [node_id]};
+     used_vars: @mut [node_id],
+     ignore: bool};
 
 /* mapping from node ID to typestate annotation */
 type node_ann_table = @mut [mut ts_ann];

src/rustc/middle/tstate/ck.rs

@@ -116,10 +116,11 @@ fn fn_states(fk: visit::fn_kind, f_decl: ast::fn_decl, f_body: ast::blk,
              sp: span, id: node_id,
              ccx: crate_ctxt, v: visit::vt<crate_ctxt>) {
 
+    visit::visit_fn(fk, f_decl, f_body, sp, id, ccx, v);
+
     // We may not care about typestate for this function if it contains
     // no constrained calls
-    if ccx.fm.contains_key(id) {
-        visit::visit_fn(fk, f_decl, f_body, sp, id, ccx, v);
+    if !ccx.fm.get(id).ignore {
         /* Look up the var-to-bit-num map for this function */
 
         let f_info = ccx.fm.get(id);

src/rustc/middle/tstate/collect_locals.rs

@@ -69,6 +69,34 @@ fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) ->
     ret next + 1u;
 }
 
+fn contains_constrained_calls(tcx: ty::ctxt, body: blk) -> bool {
+    type cx = @{
+        tcx: ty::ctxt,
+        mut has: bool
+    };
+    let cx = @{
+        tcx: tcx,
+        mut has: false
+    };
+    let vtor = visit::default_visitor::<cx>();
+    let vtor = @{visit_expr: visit_expr with *vtor};
+    visit::visit_block(body, cx, visit::mk_vt(vtor));
+    ret cx.has;
+
+    fn visit_expr(e: @expr, &&cx: cx, v: visit::vt<cx>) {
+        import syntax::print::pprust;
+        #debug("visiting %?", pprust::expr_to_str(e));
+
+        visit::visit_expr(e, cx, v);
+
+        if constraints_expr(cx.tcx, e).is_not_empty() {
+            #debug("has constraints");
+            cx.has = true;
+        } else {
+            #debug("has not constraints");
+        }
+    }
+}
 
 /* builds a table mapping each local var defined in f
    to a bit number in the precondition/postcondition vectors */
@@ -86,24 +114,29 @@ fn mk_fn_info(ccx: crate_ctxt,
     /* now we have to add bit nums for both the constraints
        and the variables... */
 
-    let mut i = 0u, l = vec::len(*cx.cs);
-    while i < l {
-        next = add_constraint(cx.tcx, copy cx.cs[i], next, res_map);
-        i += 1u;
-    }
-    /* if this function has any constraints, instantiate them to the
-       argument names and add them */
-    for f_decl.constraints.each {|c|
-        let sc = ast_constr_to_sp_constr(cx.tcx, f_decl.inputs, c);
-        next = add_constraint(cx.tcx, sc, next, res_map);
+    let ignore = !contains_constrained_calls(ccx.tcx, f_body);
+
+    if !ignore {
+        let mut i = 0u, l = vec::len(*cx.cs);
+        while i < l {
+            next = add_constraint(cx.tcx, copy cx.cs[i], next, res_map);
+            i += 1u;
+        }
+        /* if this function has any constraints, instantiate them to the
+        argument names and add them */
+        for f_decl.constraints.each {|c|
+            let sc = ast_constr_to_sp_constr(cx.tcx, f_decl.inputs, c);
+            next = add_constraint(cx.tcx, sc, next, res_map);
+        }
     }
 
     let v: @mut [node_id] = @mut [];
     let rslt =
         {constrs: res_map,
          num_constraints: next,
          cf: f_decl.cf,
-         used_vars: v};
+         used_vars: v,
+         ignore: ignore};
     ccx.fm.insert(id, rslt);
     #debug("%s has %u constraints", name, num_constraints(rslt));
 }

src/rustc/middle/tstate/pre_post_conditions.rs

@@ -618,42 +618,13 @@ fn find_pre_post_fn(fcx: fn_ctxt, body: blk) {
     }
 }
 
-fn contains_constrained_calls(tcx: ty::ctxt, body: blk) -> bool {
-    type cx = @{
-        tcx: ty::ctxt,
-        mut has: bool
-    };
-    let cx = @{
-        tcx: tcx,
-        mut has: false
-    };
-    let vtor = visit::default_visitor::<cx>();
-    let vtor = @{visit_expr: visit_expr with *vtor};
-    visit::visit_block(body, cx, visit::mk_vt(vtor));
-    ret cx.has;
-
-    fn visit_expr(e: @expr, &&cx: cx, v: visit::vt<cx>) {
-        import syntax::print::pprust;
-        #debug("visiting %?", pprust::expr_to_str(e));
-
-        visit::visit_expr(e, cx, v);
-
-        if constraints_expr(cx.tcx, e).is_not_empty() {
-            #debug("has constraints");
-            cx.has = true;
-        } else {
-            #debug("has not constraints");
-        }
-    }
-}
-
 fn fn_pre_post(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
                id: node_id,
                ccx: crate_ctxt, v: visit::vt<crate_ctxt>) {
 
-    if contains_constrained_calls(ccx.tcx, body) {
-        visit::visit_fn(fk, decl, body, sp, id, ccx, v);
-        assert (ccx.fm.contains_key(id));
+    visit::visit_fn(fk, decl, body, sp, id, ccx, v);
+    assert (ccx.fm.contains_key(id));
+    if !ccx.fm.get(id).ignore {
         let fcx =
             {enclosing: ccx.fm.get(id),
              id: id,