---

yaml
---
r: 3252
b: refs/heads/master
c: cf9ed08
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4255d58aa5db2a05362c4435a0e807205e1b8ed7
+refs/heads/master: cf9ed08a5091733b6b0c6cc38e53542b05e8dd04

trunk/src/comp/back/link.rs

@@ -33,8 +33,8 @@ tag output_type {
 fn llvm_err(session::session sess, str msg) {
     auto buf = llvm::LLVMRustGetLastError();
     if (buf as uint == 0u) {
-        sess.fatal(msg);
-    } else { sess.fatal(msg + ": " + str::str_from_cstr(buf)); }
+        sess.err(msg);
+    } else { sess.err(msg + ": " + str::str_from_cstr(buf)); }
     fail;
 }
 
@@ -276,7 +276,7 @@ fn get_crate_meta_export(&session::session sess, &ast::crate c, str k,
         }
         case (1u) { ret v.(0).node.value; }
         case (_) {
-            sess.span_fatal(v.(1).span, #fmt("duplicate meta '%s'", k));
+            sess.span_err(v.(1).span, #fmt("duplicate meta '%s'", k));
         }
     }
 }

trunk/src/comp/driver/rustc.rs

@@ -59,7 +59,7 @@ fn parse_input(session::session sess, parser::parser p, str input) ->
             parser::parse_crate_from_crate_file(p)
         } else if (str::ends_with(input, ".rs")) {
             parser::parse_crate_from_source_file(p)
-        } else { sess.fatal("unknown input file type: " + input); fail };
+        } else { sess.err("unknown input file type: " + input); fail };
 }
 
 fn time[T](bool do_it, str what, fn() -> T  thunk) -> T {
@@ -272,7 +272,7 @@ fn build_session(@session::options sopts) -> session::session {
     auto target_crate_num = 0;
     auto sess =
         session::session(target_crate_num, target_cfg, sopts, crate_cache,
-                         front::codemap::new_codemap(), 0u);
+                         front::codemap::new_codemap());
     ret sess;
 }
 
@@ -282,7 +282,7 @@ fn parse_pretty(session::session sess, &str name) -> pp_mode {
     } else if (str::eq(name, "typed")) {
         ret ppm_typed;
     } else if (str::eq(name, "identified")) { ret ppm_identified; }
-    sess.fatal("argument to `pretty` must be one of `normal`, `typed`, or " +
+    sess.err("argument to `pretty` must be one of `normal`, `typed`, or " +
                  "`identified`");
 }
 
@@ -321,16 +321,16 @@ fn main(vec[str] args) {
     auto glue = opt_present(match, "glue");
     if (glue) {
         if (n_inputs > 0u) {
-            sess.fatal("No input files allowed with --glue.");
+            sess.err("No input files allowed with --glue.");
         }
         auto out = option::from_maybe[str]("glue.bc", output_file);
         middle::trans::make_common_glue(sess, out);
         ret;
     }
     if (n_inputs == 0u) {
-        sess.fatal("No input filename given.");
+        sess.err("No input filename given.");
     } else if (n_inputs > 1u) {
-        sess.fatal("Multiple input filenames provided.");
+        sess.err("Multiple input filenames provided.");
     }
     auto ifile = match.free.(0);
     let str saved_out_filename = "";

trunk/src/comp/driver/session.rs

@@ -66,34 +66,20 @@ obj session(ast::crate_num cnum,
             @config targ_cfg,
             @options opts,
             map::hashmap[int, crate_metadata] crates,
-            codemap::codemap cm,
-            mutable uint err_count) {
+            codemap::codemap cm) {
     fn get_targ_cfg() -> @config { ret targ_cfg; }
     fn get_opts() -> @options { ret opts; }
     fn get_targ_crate_num() -> ast::crate_num { ret cnum; }
-    fn span_fatal(span sp, str msg) -> ! {
+    fn span_err(span sp, str msg) -> ! {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
 
         emit_diagnostic(some(sp), msg, "error", 9u8, cm);
         fail;
     }
-    fn fatal(str msg) -> ! {
+    fn err(str msg) -> ! {
         emit_diagnostic(none[span], msg, "error", 9u8, cm);
         fail;
     }
-    fn span_err(span sp, str msg) {
-        emit_diagnostic(some(sp), msg, "error", 9u8, cm);
-        err_count += 1u;
-    }
-    fn err(span sp, str msg) {
-        emit_diagnostic(some(sp), msg, "error", 9u8, cm);
-        err_count += 1u;
-    }
-    fn abort_if_errors() {
-        if (err_count > 0u) {
-            self.fatal("aborting due to previous errors");
-        }
-    }
     fn span_warn(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
 
@@ -108,10 +94,10 @@ obj session(ast::crate_num cnum,
         emit_diagnostic(some(sp), msg, "note", 10u8, cm);
     }
     fn span_bug(span sp, str msg) -> ! {
-        self.span_fatal(sp, #fmt("internal compiler error %s", msg));
+        self.span_err(sp, #fmt("internal compiler error %s", msg));
     }
     fn bug(str msg) -> ! {
-        self.fatal(#fmt("internal compiler error %s", msg));
+        self.err(#fmt("internal compiler error %s", msg));
     }
     fn span_unimpl(span sp, str msg) -> ! {
         self.span_bug(sp, "unimplemented " + msg);

trunk/src/comp/front/eval.rs

@@ -63,15 +63,15 @@ fn lookup(session::session sess, env e, span sp, ident i) -> val {
     for (tup(ident, val) pair in e) {
         if (str::eq(i, pair._0)) { ret pair._1; }
     }
-    sess.span_fatal(sp, "unknown variable: " + i)
+    sess.span_err(sp, "unknown variable: " + i)
 }
 
 fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
     alt (lit.node) {
         case (ast::lit_bool(?b)) { val_bool(b) }
         case (ast::lit_int(?i)) { val_int(i) }
         case (ast::lit_str(?s, _)) { val_str(s) }
-        case (_) { cx.sess.span_fatal(sp, "evaluating unsupported literal") }
+        case (_) { cx.sess.span_err(sp, "evaluating unsupported literal") }
     }
 }
 
@@ -82,18 +82,18 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
                     vec::len[@ast::ty](pth.node.types) == 0u) {
                 ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
             }
-            cx.sess.span_fatal(x.span, "evaluating structured path-name");
+            cx.sess.span_err(x.span, "evaluating structured path-name");
         }
         case (ast::expr_lit(?lit, _)) { ret eval_lit(cx, x.span, lit); }
         case (ast::expr_unary(?op, ?a, _)) {
             auto av = eval_expr(cx, e, a);
             alt (op) {
                 case (ast::not) {
                     if (val_is_bool(av)) { ret val_bool(!val_as_bool(av)); }
-                    cx.sess.span_fatal(x.span, "bad types in '!' expression");
+                    cx.sess.span_err(x.span, "bad types in '!' expression");
                 }
                 case (_) {
-                    cx.sess.span_fatal(x.span, "evaluating unsupported unop");
+                    cx.sess.span_err(x.span, "evaluating unsupported unop");
                 }
             }
         }
@@ -108,45 +108,43 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
                     if (val_is_str(av) && val_is_str(bv)) {
                         ret val_str(val_as_str(av) + val_as_str(bv));
                     }
-                    cx.sess.span_fatal(x.span, "bad types in '+' expression");
+                    cx.sess.span_err(x.span, "bad types in '+' expression");
                 }
                 case (ast::sub) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) - val_as_int(bv));
                     }
-                    cx.sess.span_fatal(x.span, "bad types in '-' expression");
+                    cx.sess.span_err(x.span, "bad types in '-' expression");
                 }
                 case (ast::mul) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) * val_as_int(bv));
                     }
-                    cx.sess.span_fatal(x.span, "bad types in '*' expression");
+                    cx.sess.span_err(x.span, "bad types in '*' expression");
                 }
                 case (ast::div) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) / val_as_int(bv));
                     }
-                    cx.sess.span_fatal(x.span, "bad types in '/' expression");
+                    cx.sess.span_err(x.span, "bad types in '/' expression");
                 }
                 case (ast::rem) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) % val_as_int(bv));
                     }
-                    cx.sess.span_fatal(x.span, "bad types in '%' expression");
+                    cx.sess.span_err(x.span, "bad types in '%' expression");
                 }
                 case (ast::and) {
                     if (val_is_bool(av) && val_is_bool(bv)) {
                         ret val_bool(val_as_bool(av) && val_as_bool(bv));
                     }
-                    cx.sess.span_fatal(x.span,
-                                       "bad types in '&&' expression");
+                    cx.sess.span_err(x.span, "bad types in '&&' expression");
                 }
                 case (ast::or) {
                     if (val_is_bool(av) && val_is_bool(bv)) {
                         ret val_bool(val_as_bool(av) || val_as_bool(bv));
                     }
-                    cx.sess.span_fatal(x.span,
-                                       "bad types in '||' expression");
+                    cx.sess.span_err(x.span, "bad types in '||' expression");
                 }
                 case (ast::eq) {
                     ret val_bool(val_eq(cx.sess, x.span, av, bv));
@@ -155,13 +153,12 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
                     ret val_bool(!val_eq(cx.sess, x.span, av, bv));
                 }
                 case (_) {
-                    cx.sess.span_fatal(x.span,
-                                       "evaluating unsupported binop");
+                    cx.sess.span_err(x.span, "evaluating unsupported binop");
                 }
             }
         }
         case (_) {
-            cx.sess.span_fatal(x.span, "evaluating unsupported expression");
+            cx.sess.span_err(x.span, "evaluating unsupported expression");
         }
     }
     fail;
@@ -174,7 +171,7 @@ fn val_eq(session::session sess, span sp, val av, val bv) -> bool {
         val_as_int(av) == val_as_int(bv)
     } else if (val_is_str(av) && val_is_str(bv)) {
         str::eq(val_as_str(av), val_as_str(bv))
-    } else { sess.span_fatal(sp, "bad types in comparison") }
+    } else { sess.span_err(sp, "bad types in comparison") }
 }
 
 fn eval_crate_directives(ctx cx, env e, vec[@ast::crate_directive] cdirs,
@@ -203,7 +200,7 @@ fn eval_crate_directive_block(ctx cx, env e, &ast::block blk, str prefix,
                 eval_crate_directive(cx, e, cdir, prefix, view_items, items);
             }
             case (_) {
-                cx.sess.span_fatal(s.span,
+                cx.sess.span_err(s.span,
                                  "unsupported stmt in crate-directive block");
             }
         }
@@ -217,7 +214,7 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
         case (ast::expr_if(?cond, ?thn, ?elopt, _)) {
             auto cv = eval_expr(cx, e, cond);
             if (!val_is_bool(cv)) {
-                cx.sess.span_fatal(x.span, "bad cond type in 'if'");
+                cx.sess.span_err(x.span, "bad cond type in 'if'");
             }
             if (val_as_bool(cv)) {
                 ret eval_crate_directive_block(cx, e, thn, prefix, view_items,
@@ -252,18 +249,18 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
                                                        items);
                     }
                     case (_) {
-                        cx.sess.span_fatal(arm.pat.span,
+                        cx.sess.span_err(arm.pat.span,
                                          "bad pattern type in 'alt'");
                     }
                 }
             }
-            cx.sess.span_fatal(x.span, "no cases matched in 'alt'");
+            cx.sess.span_err(x.span, "no cases matched in 'alt'");
         }
         case (ast::expr_block(?block, _)) {
             ret eval_crate_directive_block(cx, e, block, prefix, view_items,
                                            items);
         }
-        case (_) { cx.sess.span_fatal(x.span, "unsupported expr type"); }
+        case (_) { cx.sess.span_err(x.span, "unsupported expr type"); }
     }
 }
 

trunk/src/comp/front/ext.rs

@@ -31,23 +31,21 @@ type next_ann_fn = fn() -> ast::ann ;
 // Provides a limited set of services necessary for syntax extensions
 // to do their thing
 type ext_ctxt =
-    rec(span_msg_fn span_fatal,
-        span_msg_fn span_unimpl,
-        next_ann_fn next_ann);
+    rec(span_msg_fn span_err, span_msg_fn span_unimpl, next_ann_fn next_ann);
 
 fn mk_ctxt(parser parser) -> ext_ctxt {
     auto sess = parser.get_session();
-    fn ext_span_fatal_(session sess, span sp, str msg) -> ! {
-        sess.span_fatal(sp, msg);
+    fn ext_span_err_(session sess, span sp, str msg) -> ! {
+        sess.span_err(sp, msg);
     }
-    auto ext_span_fatal = bind ext_span_fatal_(sess, _, _);
+    auto ext_span_err = bind ext_span_err_(sess, _, _);
     fn ext_span_unimpl_(session sess, span sp, str msg) -> ! {
         sess.span_unimpl(sp, msg);
     }
     auto ext_span_unimpl = bind ext_span_unimpl_(sess, _, _);
     fn ext_next_ann_(parser parser) -> ast::ann { parser.get_ann() }
     auto ext_next_ann = bind ext_next_ann_(parser);
-    ret rec(span_fatal=ext_span_fatal,
+    ret rec(span_err=ext_span_err,
             span_unimpl=ext_span_unimpl,
             next_ann=ext_next_ann);
 }

trunk/src/comp/front/extenv.rs

@@ -16,7 +16,7 @@ export expand_syntax_ext;
 fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
                      option::t[str] body) -> @ast::expr {
     if (vec::len[@ast::expr](args) != 1u) {
-        cx.span_fatal(sp, "malformed #env call");
+        cx.span_err(sp, "malformed #env call");
     }
     // FIXME: if this was more thorough it would manufacture an
     // option::t[str] rather than just an maybe-empty string.
@@ -35,10 +35,10 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
         case (ast::expr_lit(?l, _)) {
             alt (l.node) {
                 case (ast::lit_str(?s, _)) { ret s; }
-                case (_) { cx.span_fatal(l.span, "malformed #env call"); }
+                case (_) { cx.span_err(l.span, "malformed #env call"); }
             }
         }
-        case (_) { cx.span_fatal(expr.span, "malformed #env call"); }
+        case (_) { cx.span_err(expr.span, "malformed #env call"); }
     }
 }
 

trunk/src/comp/front/extfmt.rs

@@ -18,14 +18,14 @@ export expand_syntax_ext;
 fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
                      option::t[str] body) -> @ast::expr {
     if (vec::len[@ast::expr](args) == 0u) {
-        cx.span_fatal(sp, "#fmt requires a format string");
+        cx.span_err(sp, "#fmt requires a format string");
     }
     auto fmt = expr_to_str(cx, args.(0));
     auto fmtspan = args.(0).span;
     log "Format string:";
     log fmt;
     fn parse_fmt_err_(&ext_ctxt cx, common::span sp, str msg) -> ! {
-        cx.span_fatal(sp, msg);
+        cx.span_err(sp, msg);
     }
     auto parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
     auto pieces = parse_fmt_string(fmt, parse_fmt_err);
@@ -40,10 +40,10 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
         case (ast::expr_lit(?l, _)) {
             alt (l.node) {
                 case (ast::lit_str(?s, _)) { ret s; }
-                case (_) { cx.span_fatal(l.span, err_msg); }
+                case (_) { cx.span_err(l.span, err_msg); }
             }
         }
-        case (_) { cx.span_fatal(expr.span, err_msg); }
+        case (_) { cx.span_err(expr.span, err_msg); }
     }
 }
 
@@ -236,14 +236,14 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
                 case (flag_left_justify) { }
                 case (flag_sign_always) {
                     if (!is_signed_type(cnv)) {
-                        cx.span_fatal(sp,
+                        cx.span_err(sp,
                                     "+ flag only valid in " +
                                         "signed #fmt conversion");
                     }
                 }
                 case (flag_space_for_sign) {
                     if (!is_signed_type(cnv)) {
-                        cx.span_fatal(sp,
+                        cx.span_err(sp,
                                     "space flag only valid in " +
                                         "signed #fmt conversions");
                     }
@@ -361,7 +361,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
             case (piece_conv(?conv)) {
                 n += 1u;
                 if (n >= nargs) {
-                    cx.span_fatal(sp,
+                    cx.span_err(sp,
                                 "not enough arguments to #fmt " +
                                     "for the given format string");
                 }
@@ -376,7 +376,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
     auto expected_nargs = n + 1u; // n conversions + the fmt string
 
     if (expected_nargs < nargs) {
-        cx.span_fatal(sp,
+        cx.span_err(sp,
                     #fmt("too many arguments to #fmt. found %u, expected %u",
                          nargs, expected_nargs));
     }