Fixed bug in typeck that wasn't filling in anns for stmts

(needed for typestate_check).

Also changed a (log; fail) to (log_err; fail) in typestate_check,
and added some more logging funs in util.common.

src/comp/middle/typeck.rs

@@ -2623,22 +2623,25 @@ fn check_stmt(&@fn_ctxt fcx, &@ast.stmt stmt) -> @ast.stmt {
                 case (ast.decl_local(_)) {
                     auto decl_1 = check_decl_local(fcx, decl);
                     ret @fold.respan[ast.stmt_](stmt.span,
-                                                ast.stmt_decl(decl_1, a));
+                           ast.stmt_decl(decl_1, plain_ann(fcx.ccx.tystore)));
                 }
 
                 case (ast.decl_item(_)) {
                     // Ignore for now. We'll return later.
+                    ret @fold.respan[ast.stmt_](stmt.span,
+                           ast.stmt_decl(decl, plain_ann(fcx.ccx.tystore)));
                 }
             }
 
-            ret stmt;
+            //         ret stmt;
         }
 
         case (ast.stmt_expr(?expr,?a)) {
             auto expr_t = check_expr(fcx, expr);
             expr_t = Pushdown.pushdown_expr(fcx, expr_ty(fcx.ccx.tcx, expr_t),
                                             expr_t);
-            ret @fold.respan[ast.stmt_](stmt.span, ast.stmt_expr(expr_t, a));
+            ret @fold.respan[ast.stmt_](stmt.span,
+                   ast.stmt_expr(expr_t, plain_ann(fcx.ccx.tystore)));
         }
     }
 

src/comp/middle/typestate_check.rs

@@ -105,6 +105,8 @@ import util.common.log_expr_err;
 import util.common.log_stmt;
 import util.common.log_block;
 import util.common.log_stmt_err;
+import util.common.log_fn_err;
+import util.common.log_fn;
 import util.common.log_block_err;
 import util.common.has_nonlocal_exits;
 import util.common.decl_lhs;
@@ -889,11 +891,11 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
     fn pp_one(&@expr e) -> pre_and_post {
         ret expr_pp(*e);
     }
-    /*
+    
         log("find_pre_post_expr (num_locals =" +
              uistr(num_local_vars) + "):");
-          log_expr(e);
-    */
+        log_expr(e);
+    
     alt (e.node) {
         case (expr_call(?operator, ?operands, ?a)) {
             auto args = _vec.clone[@expr](operands);
@@ -1201,6 +1203,9 @@ fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
 
 fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
     -> () {
+    log("stmt =");
+    log_stmt(s);
+
   auto num_local_vars = num_locals(enclosing);
   alt(s.node) {
     case(ast.stmt_decl(?adecl, ?a)) {
@@ -1311,6 +1316,9 @@ fn find_pre_post_fn(&fn_info_map fm, &fn_info fi, &_fn f) -> () {
 fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f,
                  vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
 
+    log("check_item_fn:");
+    log_fn(f, i, ty_params);
+
   check (fm.contains_key(id));
   find_pre_post_fn(fm, fm.get(id), f);  
 
@@ -1413,7 +1421,7 @@ fn set_pre_and_post(&ann a, pre_and_post pp) -> () {
             set_postcondition(t, pp.postcondition);
         }
         case (ann_none) {
-            log("set_pre_and_post: expected an ann_type here");
+            log_err("set_pre_and_post: expected an ann_type here");
             fail;
         }
     }
@@ -1749,7 +1757,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
                 changed = find_pre_post_state_block(fm, enclosing, e_post,
                                                     an_alt.block) || changed;
                 changed = intersect(a_post, block_poststate(an_alt.block))
-                    || changed;
+                    || changed; 
             }
         }
         else {

src/comp/util/common.rs

@@ -16,6 +16,7 @@ import std.io.string_writer;
 import pretty.pprust.print_block;
 import pretty.pprust.print_expr;
 import pretty.pprust.print_decl;
+import pretty.pprust.print_fn;
 import pretty.pp.mkstate;
 
 type filename = str;
@@ -169,6 +170,25 @@ fn log_ann(&ast.ann a) -> () {
     }
 }
 
+fn fun_to_str(&ast._fn f, str name, vec[ast.ty_param] params) -> str {
+ let str_writer s = string_writer();
+  auto out_ = mkstate(s.get_writer(), 80u);
+  auto out = @rec(s=out_,
+                  comments=none[vec[front.lexer.cmnt]],
+                  mutable cur_cmnt=0u);
+
+  print_fn(out, f.decl, name, params);
+  ret s.get_str();
+}
+
+fn log_fn(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
+    log(fun_to_str(f, name, params));
+}
+
+fn log_fn_err(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
+    log_err(fun_to_str(f, name, params));
+}
+
 fn stmt_to_str(&ast.stmt st) -> str {
   let str_writer s = string_writer();
   auto out_ = mkstate(s.get_writer(), 80u);