user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rustc: Rename session.span_err -> span_fatal, err -> fatal

Browse source 
Issue #440
This commit is contained in:
Brian Anderson 2011-06-18 22:41:20 -07:00
parent 514813148b
commit c394a7f49a
16 changed files with 136 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

43
src/comp/front/eval.rs
View file

@ -63,7 +63,7 @@ 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_err(sp, "unknown variable: " + i)
sess.span_fatal(sp, "unknown variable: " + i)
}
fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
@ -71,7 +71,7 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
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_err(sp, "evaluating unsupported literal") }
case (_) { cx.sess.span_fatal(sp, "evaluating unsupported literal") }
}
}
@ -82,7 +82,7 @@ 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_err(x.span, "evaluating structured path-name");
cx.sess.span_fatal(x.span, "evaluating structured path-name");
}
case (ast::expr_lit(?lit, _)) { ret eval_lit(cx, x.span, lit); }
case (ast::expr_unary(?op, ?a, _)) {
@ -90,10 +90,10 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
alt (op) {
case (ast::not) {
if (val_is_bool(av)) { ret val_bool(!val_as_bool(av)); }
cx.sess.span_err(x.span, "bad types in '!' expression");
cx.sess.span_fatal(x.span, "bad types in '!' expression");
}
case (_) {
cx.sess.span_err(x.span, "evaluating unsupported unop");
cx.sess.span_fatal(x.span, "evaluating unsupported unop");
}
}
}
@ -108,43 +108,45 @@ 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_err(x.span, "bad types in '+' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '-' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '*' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '/' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '%' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '&&' expression");
cx.sess.span_fatal(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_err(x.span, "bad types in '||' expression");
cx.sess.span_fatal(x.span,
"bad types in '||' expression");
}
case (ast::eq) {
ret val_bool(val_eq(cx.sess, x.span, av, bv));
@ -153,12 +155,13 @@ 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_err(x.span, "evaluating unsupported binop");
cx.sess.span_fatal(x.span,
"evaluating unsupported binop");
}
}
}
case (_) {
cx.sess.span_err(x.span, "evaluating unsupported expression");
cx.sess.span_fatal(x.span, "evaluating unsupported expression");
}
}
fail;
@ -171,7 +174,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_err(sp, "bad types in comparison") }
} else { sess.span_fatal(sp, "bad types in comparison") }
}
fn eval_crate_directives(ctx cx, env e, vec[@ast::crate_directive] cdirs,
@ -200,7 +203,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_err(s.span,
cx.sess.span_fatal(s.span,
"unsupported stmt in crate-directive block");
}
}
@ -214,7 +217,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_err(x.span, "bad cond type in 'if'");
cx.sess.span_fatal(x.span, "bad cond type in 'if'");
}
if (val_as_bool(cv)) {
ret eval_crate_directive_block(cx, e, thn, prefix, view_items,
@ -249,18 +252,18 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
items);
}
case (_) {
cx.sess.span_err(arm.pat.span,
cx.sess.span_fatal(arm.pat.span,
"bad pattern type in 'alt'");
}
}
}
cx.sess.span_err(x.span, "no cases matched in 'alt'");
cx.sess.span_fatal(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_err(x.span, "unsupported expr type"); }
case (_) { cx.sess.span_fatal(x.span, "unsupported expr type"); }
}
}

12
src/comp/front/ext.rs
View file

@ -31,21 +31,23 @@ 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_err, span_msg_fn span_unimpl, next_ann_fn next_ann);
rec(span_msg_fn span_fatal,
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_err_(session sess, span sp, str msg) -> ! {
sess.span_err(sp, msg);
fn ext_span_fatal_(session sess, span sp, str msg) -> ! {
sess.span_fatal(sp, msg);
}
auto ext_span_err = bind ext_span_err_(sess, _, _);
auto ext_span_fatal = bind ext_span_fatal_(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_err=ext_span_err,
ret rec(span_fatal=ext_span_fatal,
span_unimpl=ext_span_unimpl,
next_ann=ext_next_ann);
}

6
src/comp/front/extenv.rs
View file

@ -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_err(sp, "malformed #env call");
cx.span_fatal(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_err(l.span, "malformed #env call"); }
case (_) { cx.span_fatal(l.span, "malformed #env call"); }
}
}
case (_) { cx.span_err(expr.span, "malformed #env call"); }
case (_) { cx.span_fatal(expr.span, "malformed #env call"); }
}
}

16
src/comp/front/extfmt.rs
View file

@ -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_err(sp, "#fmt requires a format string");
cx.span_fatal(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_err(sp, msg);
cx.span_fatal(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_err(l.span, err_msg); }
case (_) { cx.span_fatal(l.span, err_msg); }
}
}
case (_) { cx.span_err(expr.span, err_msg); }
case (_) { cx.span_fatal(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_err(sp,
cx.span_fatal(sp,
"+ flag only valid in " +
"signed #fmt conversion");
}
}
case (flag_space_for_sign) {
if (!is_signed_type(cnv)) {
cx.span_err(sp,
cx.span_fatal(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_err(sp,
cx.span_fatal(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_err(sp,
cx.span_fatal(sp,
#fmt("too many arguments to #fmt. found %u, expected %u",
nargs, expected_nargs));
}

2
src/comp/front/lexer.rs
View file

@ -75,7 +75,7 @@ fn new_reader(session sess, io::reader rdr, codemap::filemap filemap,
fn get_interner() -> @interner::interner[str] { ret itr; }
fn get_col() -> uint { ret col; }
fn get_filemap() -> codemap::filemap { ret fm; }
fn err(str m) { sess.span_err(rec(lo=chpos, hi=chpos), m); }
fn err(str m) { sess.span_fatal(rec(lo=chpos, hi=chpos), m); }
}
auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = [];

4
src/comp/front/parser.rs
View file

@ -78,7 +78,7 @@ fn new_parser(session::session sess, eval::env env, ast::def_id initial_def,
lo = rdr.get_mark_chpos();
hi = rdr.get_chpos();
}
fn err(str m) -> ! { sess.span_err(rec(lo=lo, hi=hi), m); }
fn err(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }
fn restrict(restriction r) { res = r; }
fn get_restriction() -> restriction { ret res; }
fn get_session() -> session::session { ret sess; }
@ -353,7 +353,7 @@ fn parse_ty_field(&parser p) -> ast::ty_field {
fn ident_index(&parser p, &vec[ast::arg] args, &ast::ident i) -> uint {
auto j = 0u;
for (ast::arg a in args) { if (a.ident == i) { ret j; } j += 1u; }
p.get_session().span_err(p.get_span(),
p.get_session().span_fatal(p.get_span(),
"Unbound variable " + i + " in constraint arg");
}