add log_err to rustc

src/comp/front/ast.rs

@@ -289,7 +289,7 @@ tag expr_ {
     expr_ret(option.t[@expr], ann);
     expr_put(option.t[@expr], ann);
     expr_be(@expr, ann);
-    expr_log(@expr, ann);
+    expr_log(int, @expr, ann);
     expr_check_expr(@expr, ann);
     expr_port(ann);
     expr_chan(@expr, ann);

src/comp/front/lexer.rs

@@ -152,6 +152,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
     keywords.insert("const", token.CONST);
 
     keywords.insert("log", token.LOG);
+    keywords.insert("log_err", token.LOG_ERR);
     keywords.insert("spawn", token.SPAWN);
     keywords.insert("thread", token.THREAD);
     keywords.insert("yield", token.YIELD);

src/comp/front/parser.rs

@@ -810,7 +810,14 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
             p.bump();
             auto e = parse_expr(p);
             auto hi = e.span.hi;
-            ex = ast.expr_log(e, ast.ann_none);
+            ex = ast.expr_log(1, e, ast.ann_none);
+        }
+
+        case (token.LOG_ERR) {
+            p.bump();
+            auto e = parse_expr(p);
+            auto hi = e.span.hi;
+            ex = ast.expr_log(0, e, ast.ann_none);
         }
 
         case (token.CHECK) {
@@ -1669,7 +1676,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
                 case (ast.expr_ret(_,_))        { ret true; }
                 case (ast.expr_put(_,_))        { ret true; }
                 case (ast.expr_be(_,_))         { ret true; }
-                case (ast.expr_log(_,_))        { ret true; }
+                case (ast.expr_log(_,_,_))        { ret true; }
                 case (ast.expr_check_expr(_,_)) { ret true; }
             }
         }

src/comp/front/token.rs

@@ -119,6 +119,7 @@ tag token {
 
     /* Magic runtime services */
     LOG;
+    LOG_ERR;
     SPAWN;
     BIND;
     THREAD;
@@ -291,6 +292,7 @@ fn to_str(token t) -> str {
 
         /* Magic runtime services */
         case (LOG) { ret "log"; }
+        case (LOG_ERR) { ret "log_err"; }
         case (SPAWN) { ret "spawn"; }
         case (BIND) { ret "bind"; }
         case (THREAD) { ret "thread"; }

src/comp/middle/fold.rs

@@ -193,7 +193,7 @@ type ast_fold[ENV] =
      (fn(&ENV e, &span sp,
          @expr e, ann a) -> @expr)                fold_expr_be,
 
-     (fn(&ENV e, &span sp,
+     (fn(&ENV e, &span sp, int lvl,
          @expr e, ann a) -> @expr)                fold_expr_log,
 
      (fn(&ENV e, &span sp,
@@ -793,10 +793,10 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
             ret fld.fold_expr_be(env_, e.span, ee, t2);
         }
 
-        case (ast.expr_log(?x, ?t)) {
+        case (ast.expr_log(?l, ?x, ?t)) {
             auto ee = fold_expr(env_, fld, x);
             auto t2 = fld.fold_ann(env_, t);
-            ret fld.fold_expr_log(env_, e.span, ee, t2);
+            ret fld.fold_expr_log(env_, e.span, l, ee, t2);
         }
 
         case (ast.expr_check_expr(?x, ?t)) {
@@ -1378,9 +1378,9 @@ fn identity_fold_expr_be[ENV](&ENV env, &span sp, @expr x, ann a) -> @expr {
     ret @respan(sp, ast.expr_be(x, a));
 }
 
-fn identity_fold_expr_log[ENV](&ENV e, &span sp, @expr x,
+fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x,
                                ann a) -> @expr {
-    ret @respan(sp, ast.expr_log(x, a));
+    ret @respan(sp, ast.expr_log(lvl, x, a));
 }
 
 fn identity_fold_expr_check_expr[ENV](&ENV e, &span sp, @expr x, ann a)
@@ -1679,7 +1679,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
          fold_expr_ret    = bind identity_fold_expr_ret[ENV](_,_,_,_),
          fold_expr_put    = bind identity_fold_expr_put[ENV](_,_,_,_),
          fold_expr_be     = bind identity_fold_expr_be[ENV](_,_,_,_),
-         fold_expr_log    = bind identity_fold_expr_log[ENV](_,_,_,_),
+         fold_expr_log    = bind identity_fold_expr_log[ENV](_,_,_,_,_),
          fold_expr_check_expr
          = bind identity_fold_expr_check_expr[ENV](_,_,_,_),
          fold_expr_port   = bind identity_fold_expr_port[ENV](_,_,_),

src/comp/middle/trans.rs

@@ -4901,8 +4901,8 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
             ret trans_fail(cx, e.span, "explicit failure");
         }
 
-        case (ast.expr_log(?a, _)) {
+        case (ast.expr_log(?lvl, ?a, _)) {
-            ret trans_log(cx, a);
+            ret trans_log(lvl, cx, a);
         }
 
         case (ast.expr_check_expr(?a, _)) {
@@ -4989,7 +4989,7 @@ fn load_if_immediate(@block_ctxt cx, ValueRef v, @ty.t t) -> ValueRef {
     ret v;
 }
 
-fn trans_log(@block_ctxt cx, @ast.expr e) -> result {
+fn trans_log(int lvl, @block_ctxt cx, @ast.expr e) -> result {
     auto lcx = cx.fcx.lcx;
     auto modname = _str.connect(lcx.module_path, ".");
     auto global;
@@ -5008,7 +5008,7 @@ fn trans_log(@block_ctxt cx, @ast.expr e) -> result {
     auto log_cx = new_sub_block_ctxt(cx, "log");
     auto after_cx = new_sub_block_ctxt(cx, "after");
     auto load = cx.build.Load(global);
-    auto test = cx.build.ICmp(lib.llvm.LLVMIntSGE, load, C_int(1));
+    auto test = cx.build.ICmp(lib.llvm.LLVMIntSGE, load, C_int(lvl));
     cx.build.CondBr(test, log_cx.llbb, after_cx.llbb);
 
     auto sub = trans_expr(log_cx, e);
@@ -5032,14 +5032,14 @@ fn trans_log(@block_ctxt cx, @ast.expr e) -> result {
         if (is32bit) {
             trans_upcall(sub.bcx,
                          "upcall_log_float",
-                         vec(sub.val)).bcx.build.Br(after_cx.llbb);
+                         vec(C_int(lvl), sub.val)).bcx.build.Br(after_cx.llbb);
         } else {
             auto tmp = alloca(sub.bcx, tr);
             sub.bcx.build.Store(sub.val, tmp);
             auto v = vp2i(sub.bcx, tmp);
             trans_upcall(sub.bcx,
                          "upcall_log_double",
-                         vec(v)).bcx.build.Br(after_cx.llbb);
+                         vec(C_int(lvl), v)).bcx.build.Br(after_cx.llbb);
         }
     } else {
         alt (e_ty.struct) {
@@ -5047,12 +5047,13 @@ fn trans_log(@block_ctxt cx, @ast.expr e) -> result {
                 auto v = vp2i(sub.bcx, sub.val);
                 trans_upcall(sub.bcx,
                              "upcall_log_str",
-                             vec(v)).bcx.build.Br(after_cx.llbb);
+                             vec(C_int(lvl), v)).bcx.build.Br(after_cx.llbb);
             }
             case (_) {
+                auto v = vec(C_int(lvl), sub.val);
                 trans_upcall(sub.bcx,
                              "upcall_log_int",
-                             vec(sub.val)).bcx.build.Br(after_cx.llbb);
+                             v).bcx.build.Br(after_cx.llbb);
             }
         }
     }

src/comp/middle/ty.rs

@@ -913,7 +913,7 @@ fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
         case (ast.expr_fail(_))               { ret none[ast.ann]; }
         case (ast.expr_break(_))              { ret none[ast.ann]; }
         case (ast.expr_cont(_))               { ret none[ast.ann]; }
-        case (ast.expr_log(_,_))              { ret none[ast.ann]; }
+        case (ast.expr_log(_,_,_))            { ret none[ast.ann]; }
         case (ast.expr_check_expr(_,_))       { ret none[ast.ann]; }
         case (ast.expr_ret(_,_))              { ret none[ast.ann]; }
         case (ast.expr_put(_,_))              { ret none[ast.ann]; }

src/comp/middle/typeck.rs

@@ -1382,7 +1382,7 @@ mod Pushdown {
             }
             /* FIXME: should this check the type annotations? */
             case (ast.expr_fail(_))  { e_1 = e.node; } 
-            case (ast.expr_log(_,_)) { e_1 = e.node; } 
+            case (ast.expr_log(_,_,_)) { e_1 = e.node; } 
             case (ast.expr_break(_)) { e_1 = e.node; }
             case (ast.expr_cont(_))  { e_1 = e.node; }
             case (ast.expr_ret(_,_)) { e_1 = e.node; }
@@ -1905,10 +1905,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                                     boring_ann()));
         }
 
-        case (ast.expr_log(?e,_)) {
+        case (ast.expr_log(_,?e,_)) {
             auto expr_t = check_expr(fcx, e);
             ret @fold.respan[ast.expr_]
-                (expr.span, ast.expr_log(expr_t, boring_ann()));
+                (expr.span, ast.expr_log(_, expr_t, boring_ann()));
         }
 
         case (ast.expr_check_expr(?e, _)) {

src/comp/middle/typestate_check.rs

@@ -384,7 +384,7 @@ fn expr_ann(&expr e) -> ann {
     case (ast.expr_be(_,?a)) {
       ret a;
     }
-    case (ast.expr_log(_,?a)) {
+    case (ast.expr_log(_,_,?a)) {
       ret a;
     }
     case (ast.expr_check_expr(_,?a)) {
@@ -784,7 +784,7 @@ fn find_pre_post_expr(&_fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             // Otherwise, variable is global, so it must be initialized
             set_pre_and_post(a, res);
         }
-        case(expr_log(?arg, ?a)) {
+        case(expr_log(_, ?arg, ?a)) {
             find_pre_post_expr(fm, enclosing, *arg);
             set_pre_and_post(a, expr_pp(*arg));
         }
@@ -1099,7 +1099,7 @@ fn find_pre_post_state_expr(&_fn_info_map fm, &fn_info enclosing,
     case (expr_path(_,_,?a)) {
       ret pure_exp(a, pres);
     }
-    case (expr_log(?e,?a)) {
+    case (expr_log(_,?e,?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, e);
         changed = extend_prestate_ann(a, pres) || changed;
         changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;

src/comp/pretty/pprust.rs

@@ -647,8 +647,11 @@ impure fn print_expr(ps s, &@ast.expr expr) {
             wrd1(s, "be");
             print_expr(s, result);
         }
-        case (ast.expr_log(?expr,_)) {
+        case (ast.expr_log(?lvl,?expr,_)) {
-            wrd1(s, "log");
+            alt (lvl) {
+                case (1) {wrd1(s, "log");}
+                case (0) {wrd1(s, "log_err");}
+            }
             print_expr(s, expr);
         }
         case (ast.expr_check_expr(?expr,_)) {