bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Convert rustc::syntax::ast_util to istrs. Issue #855

Browse source
This commit is contained in:
Brian Anderson 2011-08-27 14:42:29 -07:00
parent cbad23a747
commit 9fb085560d
8 changed files with 63 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/comp/front/test.rs
View file

@ -92,7 +92,8 @@ fn fold_item(cx: &test_ctxt, i: &@ast::item, fld: fold::ast_fold) ->
@ast::item {
cx.path += [i.ident];
log #fmt["current path: %s", ast_util::path_name_i(cx.path)];
log #fmt["current path: %s",
istr::to_estr(ast_util::path_name_i(cx.path))];
if is_test_fn(i) {
log "this is a test function";
@ -248,11 +249,11 @@ fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
let path = test.path;
log #fmt["encoding %s", ast_util::path_name_i(path)];
log #fmt["encoding %s",
istr::to_estr(ast_util::path_name_i(path))];
let name_lit: ast::lit =
nospan(ast::lit_str(
istr::from_estr(ast_util::path_name_i(path)), ast::sk_rc));
nospan(ast::lit_str(ast_util::path_name_i(path), ast::sk_rc));
let name_expr: ast::expr =
{id: cx.next_node_id(),
node: ast::expr_lit(@name_lit),

8
src/comp/middle/alias.rs
View file

@ -518,16 +518,18 @@ fn test_scope(cx: &ctx, sc: &scope, r: &restrict, p: &ast::path) {
let msg =
alt prob {
overwritten(sp, wpt) {
{span: sp, msg: "overwriting " + ast_util::path_name(wpt)}
{span: sp, msg: "overwriting " +
istr::to_estr(ast_util::path_name(wpt))}
}
val_taken(sp, vpt) {
{span: sp,
msg: "taking the value of " + ast_util::path_name(vpt)}
msg: "taking the value of " +
istr::to_estr(ast_util::path_name(vpt))}
}
};
cx.tcx.sess.span_err(msg.span,
msg.msg + " will invalidate alias " +
ast_util::path_name(p) +
istr::to_estr(ast_util::path_name(p)) +
", which is still used");
}
}

2
src/comp/middle/resolve.rs
View file

@ -324,7 +324,7 @@ fn resolve_names(e: &@env, c: &@ast::crate) {
_ {
e.sess.span_err(p.span,
"not a tag variant: " +
ast_util::path_name(p));
istr::to_estr(ast_util::path_name(p)));
}
}
}

8
src/comp/middle/typeck.rs
View file

@ -1792,10 +1792,10 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
let binopstr = ast_util::binop_to_str(binop);
let t_str = ty_to_str(fcx.ccx.tcx, resolved_t);
let errmsg =
"binary operation " + binopstr +
" cannot be applied to type `" +
istr::to_estr(t_str) + "`";
fcx.ccx.tcx.sess.span_err(span, errmsg);
~"binary operation " + binopstr +
~" cannot be applied to type `" +
t_str + ~"`";
fcx.ccx.tcx.sess.span_err(span, istr::to_estr(errmsg));
}
}

78
src/comp/syntax/ast_util.rs
View file

@ -14,10 +14,10 @@ fn mk_sp(lo: uint, hi: uint) -> span {
// make this a const, once the compiler supports it
fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
fn path_name(p: &path) -> str { path_name_i(p.node.idents) }
fn path_name(p: &path) -> istr { path_name_i(p.node.idents) }
fn path_name_i(idents: &[ident]) -> str {
istr::to_estr(istr::connect(idents, ~"::"))
fn path_name_i(idents: &[ident]) -> istr {
istr::connect(idents, ~"::")
}
fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
@ -83,27 +83,27 @@ fn pat_binding_ids(pat: &@pat) -> [node_id] {
ret found;
}
fn binop_to_str(op: binop) -> str {
fn binop_to_str(op: binop) -> istr {
alt op {
add. { ret "+"; }
sub. { ret "-"; }
mul. { ret "*"; }
div. { ret "/"; }
rem. { ret "%"; }
and. { ret "&&"; }
or. { ret "||"; }
bitxor. { ret "^"; }
bitand. { ret "&"; }
bitor. { ret "|"; }
lsl. { ret "<<"; }
lsr. { ret ">>"; }
asr. { ret ">>>"; }
eq. { ret "=="; }
lt. { ret "<"; }
le. { ret "<="; }
ne. { ret "!="; }
ge. { ret ">="; }
gt. { ret ">"; }
add. { ret ~"+"; }
sub. { ret ~"-"; }
mul. { ret ~"*"; }
div. { ret ~"/"; }
rem. { ret ~"%"; }
and. { ret ~"&&"; }
or. { ret ~"||"; }
bitxor. { ret ~"^"; }
bitand. { ret ~"&"; }
bitor. { ret ~"|"; }
lsl. { ret ~"<<"; }
lsr. { ret ~">>"; }
asr. { ret ~">>>"; }
eq. { ret ~"=="; }
lt. { ret ~"<"; }
le. { ret ~"<="; }
ne. { ret ~"!="; }
ge. { ret ~">="; }
gt. { ret ~">"; }
}
}
@ -111,12 +111,12 @@ pure fn lazy_binop(b: binop) -> bool {
alt b { and. { true } or. { true } _ { false } }
}
fn unop_to_str(op: unop) -> str {
fn unop_to_str(op: unop) -> istr {
alt op {
box(mt) { if mt == mut { ret "@mutable "; } ret "@"; }
deref. { ret "*"; }
not. { ret "!"; }
neg. { ret "-"; }
box(mt) { if mt == mut { ret ~"@mutable "; } ret ~"@"; }
deref. { ret ~"*"; }
not. { ret ~"!"; }
neg. { ret ~"-"; }
}
}
@ -124,18 +124,18 @@ fn is_path(e: &@expr) -> bool {
ret alt e.node { expr_path(_) { true } _ { false } };
}
fn ty_mach_to_str(tm: ty_mach) -> str {
fn ty_mach_to_str(tm: ty_mach) -> istr {
alt tm {
ty_u8. { ret "u8"; }
ty_u16. { ret "u16"; }
ty_u32. { ret "u32"; }
ty_u64. { ret "u64"; }
ty_i8. { ret "i8"; }
ty_i16. { ret "i16"; }
ty_i32. { ret "i32"; }
ty_i64. { ret "i64"; }
ty_f32. { ret "f32"; }
ty_f64. { ret "f64"; }
ty_u8. { ret ~"u8"; }
ty_u16. { ret ~"u16"; }
ty_u32. { ret ~"u32"; }
ty_u64. { ret ~"u64"; }
ty_i8. { ret ~"i8"; }
ty_i16. { ret ~"i16"; }
ty_i32. { ret ~"i32"; }
ty_i64. { ret ~"i64"; }
ty_f32. { ret ~"f32"; }
ty_f64. { ret ~"f64"; }
}
}

4
src/comp/syntax/parse/token.rs
View file

@ -149,12 +149,12 @@ fn to_str(r: lexer::reader, t: token) -> istr {
}
LIT_UINT(u) { ret uint::to_str(u, 10u); }
LIT_MACH_INT(tm, i) {
ret int::to_str(i, 10u) + ~"_" + istr::from_estr(ty_mach_to_str(tm));
ret int::to_str(i, 10u) + ~"_" + ty_mach_to_str(tm);
}
LIT_MACH_FLOAT(tm, s) {
ret interner::get::<istr>(
*r.get_interner(), s) + ~"_" +
istr::from_estr(ty_mach_to_str(tm));
ty_mach_to_str(tm);
}
LIT_FLOAT(s) {
ret interner::get::<istr>(*r.get_interner(), s);

12
src/comp/syntax/print/pprust.rs
View file

@ -276,7 +276,7 @@ fn print_type(s: &ps, ty: &@ast::ty) {
ast::ty_uint. { word(s.s, ~"uint"); }
ast::ty_float. { word(s.s, ~"float"); }
ast::ty_machine(tm) {
word(s.s, istr::from_estr(ast_util::ty_mach_to_str(tm)));
word(s.s, ast_util::ty_mach_to_str(tm));
}
ast::ty_char. { word(s.s, ~"char"); }
ast::ty_str. { word(s.s, ~"str"); }
@ -846,11 +846,11 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
let prec = operator_prec(op);
print_maybe_parens(s, lhs, prec);
space(s.s);
word_space(s, istr::from_estr(ast_util::binop_to_str(op)));
word_space(s, ast_util::binop_to_str(op));
print_maybe_parens(s, rhs, prec + 1);
}
ast::expr_unary(op, expr) {
word(s.s, istr::from_estr(ast_util::unop_to_str(op)));
word(s.s, ast_util::unop_to_str(op));
print_maybe_parens(s, expr, parse::parser::unop_prec);
}
ast::expr_lit(lit) { print_literal(s, lit); }
@ -982,7 +982,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
ast::expr_assign_op(op, lhs, rhs) {
print_expr(s, lhs);
space(s.s);
word(s.s, istr::from_estr(ast_util::binop_to_str(op)));
word(s.s, ast_util::binop_to_str(op));
word_space(s, ~"=");
print_expr(s, rhs);
}
@ -1526,12 +1526,12 @@ fn print_literal(s: &ps, lit: &@ast::lit) {
ast::lit_float(fstr) { word(s.s, fstr); }
ast::lit_mach_int(mach, val) {
word(s.s, int::str(val as int));
word(s.s, istr::from_estr(ast_util::ty_mach_to_str(mach)));
word(s.s, ast_util::ty_mach_to_str(mach));
}
ast::lit_mach_float(mach, val) {
// val is already a str
word(s.s, val);
word(s.s, istr::from_estr(ast_util::ty_mach_to_str(mach)));
word(s.s, ast_util::ty_mach_to_str(mach));
}
ast::lit_nil. { word(s.s, ~"()"); }
ast::lit_bool(val) {

2
src/comp/util/ppaux.rs
View file

@ -114,7 +114,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> istr {
ty_int. { ~"int" }
ty_float. { ~"float" }
ty_uint. { ~"uint" }
ty_machine(tm) { istr::from_estr(ty_mach_to_str(tm)) }
ty_machine(tm) { ty_mach_to_str(tm) }
ty_char. { ~"char" }
ty_str. { ~"str" }
ty_istr. { ~"istr" }