Convert ast::ident to istr. Issue #855
This commit is contained in:
Brian Anderson
parent
652332f9d4
commit
03119fe269
34 changed files with 403 additions and 316 deletions
|
|
@ -7,7 +7,7 @@ import codemap::filename;
|
|||
|
||||
type spanned<T> = {node: T, span: span};
|
||||
|
||||
type ident = str;
|
||||
type ident = istr;
|
||||
type identistr = istr;
|
||||
|
||||
// Functions may or may not have names.
|
||||
|
|
@ -429,7 +429,7 @@ type native_mod =
|
|||
|
||||
type variant_arg = {ty: @ty, id: node_id};
|
||||
|
||||
type variant_ = {name: str, args: [variant_arg], id: node_id};
|
||||
type variant_ = {name: ident, args: [variant_arg], id: node_id};
|
||||
|
||||
type variant = spanned<variant_>;
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,9 @@ fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
|
|||
|
||||
fn path_name(p: &path) -> str { path_name_i(p.node.idents) }
|
||||
|
||||
fn path_name_i(idents: &[ident]) -> str { str::connect(idents, "::") }
|
||||
fn path_name_i(idents: &[ident]) -> str {
|
||||
istr::to_estr(istr::connect(idents, ~"::"))
|
||||
}
|
||||
|
||||
fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
|
||||
|
||||
|
|
@ -52,7 +54,7 @@ fn pat_id_map(pat: &@pat) -> pat_id_map {
|
|||
let map = std::map::new_str_hash::<node_id>();
|
||||
for each bound in pat_bindings(pat) {
|
||||
let name = alt bound.node { pat_bind(n) { n } };
|
||||
map.insert(istr::from_estr(name), bound.id);
|
||||
map.insert(name, bound.id);
|
||||
}
|
||||
ret map;
|
||||
}
|
||||
|
|
@ -156,7 +158,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
|
|||
for vi: @ast::view_item in m.view_items {
|
||||
alt vi.node {
|
||||
ast::view_item_export(ids, _) {
|
||||
for id in ids { if str::eq(i, id) { ret true; } }
|
||||
for id in ids { if istr::eq(i, id) { ret true; } }
|
||||
count += 1u;
|
||||
}
|
||||
_ {/* fall through */ }
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
|
|||
cx.span_fatal(sp, "#concat_idents requires a vector argument .")
|
||||
}
|
||||
};
|
||||
let res: ast::ident = "";
|
||||
let res: ast::ident = ~"";
|
||||
for e: @ast::expr in args {
|
||||
res += expr_to_ident(cx, e, "expected an ident");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,10 +24,11 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,
|
|||
mac_invoc(pth, args, body) {
|
||||
assert (vec::len(pth.node.idents) > 0u);
|
||||
let extname = pth.node.idents[0];
|
||||
alt exts.find(istr::from_estr(extname)) {
|
||||
alt exts.find(extname) {
|
||||
none. {
|
||||
cx.span_fatal(pth.span,
|
||||
#fmt["macro undefined: '%s'", extname])
|
||||
#fmt["macro undefined: '%s'",
|
||||
istr::to_estr(extname)])
|
||||
}
|
||||
some(normal(ext)) {
|
||||
let expanded = ext(cx, pth.span, args, body);
|
||||
|
|
|
|||
|
|
@ -100,16 +100,16 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
|
|||
let recexpr = ast::expr_rec(astfields, option::none::<@ast::expr>);
|
||||
ret @{id: cx.next_id(), node: recexpr, span: sp};
|
||||
}
|
||||
fn make_path_vec(cx: &ext_ctxt, ident: str) -> [str] {
|
||||
fn make_path_vec(cx: &ext_ctxt, ident: &ast::ident) -> [ast::ident] {
|
||||
fn compiling_std(cx: &ext_ctxt) -> bool {
|
||||
ret str::find(cx.crate_file_name(), "std.rc") >= 0;
|
||||
}
|
||||
if compiling_std(cx) {
|
||||
ret ["extfmt", "rt", ident];
|
||||
} else { ret ["std", "extfmt", "rt", ident]; }
|
||||
ret [~"extfmt", ~"rt", ident];
|
||||
} else { ret [~"std", ~"extfmt", ~"rt", ident]; }
|
||||
}
|
||||
fn make_rt_path_expr(cx: &ext_ctxt, sp: span, ident: str) -> @ast::expr {
|
||||
let path = make_path_vec(cx, ident);
|
||||
let path = make_path_vec(cx, istr::from_estr(ident));
|
||||
ret make_path_expr(cx, sp, path);
|
||||
}
|
||||
// Produces an AST expression that represents a RT::conv record,
|
||||
|
|
@ -145,7 +145,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
|
|||
}
|
||||
count_is(c) {
|
||||
let count_lit = make_new_int(cx, sp, c);
|
||||
let count_is_path = make_path_vec(cx, "count_is");
|
||||
let count_is_path = make_path_vec(cx, ~"count_is");
|
||||
let count_is_args = [count_lit];
|
||||
ret make_call(cx, sp, count_is_path, count_is_args);
|
||||
}
|
||||
|
|
@ -171,10 +171,10 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
|
|||
width_expr: @ast::expr, precision_expr: @ast::expr,
|
||||
ty_expr: @ast::expr) -> @ast::expr {
|
||||
ret make_rec_expr(cx, sp,
|
||||
[{ident: "flags", ex: flags_expr},
|
||||
{ident: "width", ex: width_expr},
|
||||
{ident: "precision", ex: precision_expr},
|
||||
{ident: "ty", ex: ty_expr}]);
|
||||
[{ident: ~"flags", ex: flags_expr},
|
||||
{ident: ~"width", ex: width_expr},
|
||||
{ident: ~"precision", ex: precision_expr},
|
||||
{ident: ~"ty", ex: ty_expr}]);
|
||||
}
|
||||
let rt_conv_flags = make_flags(cx, sp, cnv.flags);
|
||||
let rt_conv_width = make_count(cx, sp, cnv.width);
|
||||
|
|
@ -185,7 +185,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
|
|||
}
|
||||
fn make_conv_call(cx: &ext_ctxt, sp: span, conv_type: str, cnv: &conv,
|
||||
arg: @ast::expr) -> @ast::expr {
|
||||
let fname = "conv_" + conv_type;
|
||||
let fname = ~"conv_" + istr::from_estr(conv_type);
|
||||
let path = make_path_vec(cx, fname);
|
||||
let cnv_expr = make_rt_conv_expr(cx, sp, cnv);
|
||||
let args = [cnv_expr, arg];
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
import std::vec;
|
||||
import std::istr;
|
||||
import std::option;
|
||||
import base::*;
|
||||
import syntax::ast;
|
||||
|
|
@ -17,8 +18,8 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
|
|||
}
|
||||
|
||||
ret make_new_lit(cx, sp,
|
||||
ast::lit_str(expr_to_ident(cx, args[0u],
|
||||
"expected an ident"),
|
||||
ast::lit_str(istr::to_estr(expr_to_ident(cx, args[0u],
|
||||
"expected an ident")),
|
||||
ast::sk_rc));
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -268,8 +268,8 @@ iter free_vars(b: &bindings, e: @expr) -> ident {
|
|||
let idents: hashmap<identistr, ()> = new_str_hash::<()>();
|
||||
fn mark_ident(i: &ident, _fld: ast_fold, b: &bindings,
|
||||
idents: &hashmap<identistr, ()>) -> ident {
|
||||
if b.contains_key(istr::from_estr(i)) {
|
||||
idents.insert(istr::from_estr(i), ());
|
||||
if b.contains_key(i) {
|
||||
idents.insert(i, ());
|
||||
}
|
||||
ret i;
|
||||
}
|
||||
|
|
@ -281,7 +281,7 @@ iter free_vars(b: &bindings, e: @expr) -> ident {
|
|||
let f = make_fold(f_pre);
|
||||
f.fold_expr(e); // ignore result
|
||||
dummy_out(f);
|
||||
for each id: identistr in idents.keys() { put istr::to_estr(id); }
|
||||
for each id: identistr in idents.keys() { put id; }
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -298,7 +298,7 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
/* we need to walk over all the free vars in lockstep, except for
|
||||
the leaves, which are just duplicated */
|
||||
for each fv: ident in free_vars(b, repeat_me) {
|
||||
let cur_pos = follow(b.get(istr::from_estr(fv)), idx_path);
|
||||
let cur_pos = follow(b.get(fv), idx_path);
|
||||
alt cur_pos {
|
||||
leaf(_) { }
|
||||
seq(ms, _) {
|
||||
|
|
@ -310,8 +310,10 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
let len = vec::len(*ms);
|
||||
if old_len != len {
|
||||
let msg =
|
||||
#fmt["'%s' occurs %u times, but ", fv, len] +
|
||||
#fmt["'%s' occurs %u times", old_name,
|
||||
#fmt["'%s' occurs %u times, but ",
|
||||
istr::to_estr(fv), len] +
|
||||
#fmt["'%s' occurs %u times",
|
||||
istr::to_estr(old_name),
|
||||
old_len];
|
||||
cx.span_fatal(repeat_me.span, msg);
|
||||
}
|
||||
|
|
@ -350,7 +352,7 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
// substitute, in a position that's required to be an ident
|
||||
fn transcribe_ident(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
||||
i: &ident, _fld: ast_fold) -> ident {
|
||||
ret alt follow_for_trans(cx, b.find(istr::from_estr(i)), idx_path) {
|
||||
ret alt follow_for_trans(cx, b.find(i), idx_path) {
|
||||
some(match_ident(a_id)) { a_id.node }
|
||||
some(m) { match_error(cx, m, "an identifier") }
|
||||
none. { i }
|
||||
|
|
@ -362,8 +364,7 @@ fn transcribe_path(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
p: &path_, _fld: ast_fold) -> path_ {
|
||||
// Don't substitute into qualified names.
|
||||
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
|
||||
ret alt follow_for_trans(cx, b.find(
|
||||
istr::from_estr(p.idents[0])), idx_path) {
|
||||
ret alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
|
||||
some(match_ident(id)) {
|
||||
{global: false, idents: [id.node], types: []}
|
||||
}
|
||||
|
|
@ -384,8 +385,7 @@ fn transcribe_expr(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
|
||||
e
|
||||
}
|
||||
alt follow_for_trans(cx, b.find(
|
||||
istr::from_estr(p.node.idents[0])), idx_path) {
|
||||
alt follow_for_trans(cx, b.find(p.node.idents[0]), idx_path) {
|
||||
some(match_ident(id)) {
|
||||
expr_path(respan(id.span,
|
||||
{global: false,
|
||||
|
|
@ -409,8 +409,7 @@ fn transcribe_type(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
ast::ty_path(pth, _) {
|
||||
alt path_to_ident(pth) {
|
||||
some(id) {
|
||||
alt follow_for_trans(cx, b.find(
|
||||
istr::from_estr(id)), idx_path) {
|
||||
alt follow_for_trans(cx, b.find(id), idx_path) {
|
||||
some(match_ty(ty)) { ty.node }
|
||||
some(m) { match_error(cx, m, "a type") }
|
||||
none. { orig(t, fld) }
|
||||
|
|
@ -433,7 +432,7 @@ fn transcribe_block(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
|
|||
ret alt block_to_ident(blk) {
|
||||
some(id) {
|
||||
alt follow_for_trans(cx, b.find(
|
||||
istr::from_estr(id)), idx_path) {
|
||||
id), idx_path) {
|
||||
some(match_block(new_blk)) { new_blk.node }
|
||||
|
||||
|
||||
|
|
@ -534,10 +533,10 @@ fn p_t_s_r_path(cx: &ext_ctxt, p: &path, s: &selector, b: &binders) {
|
|||
_ { cx.bug("broken traversal in p_t_s_r") }
|
||||
}
|
||||
}
|
||||
if b.real_binders.contains_key(istr::from_estr(p_id)) {
|
||||
if b.real_binders.contains_key(p_id) {
|
||||
cx.span_fatal(p.span, "duplicate binding identifier");
|
||||
}
|
||||
b.real_binders.insert(istr::from_estr(p_id),
|
||||
b.real_binders.insert(p_id,
|
||||
compose_sels(s, bind select(cx, _)));
|
||||
}
|
||||
none. { }
|
||||
|
|
@ -584,7 +583,7 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
|
|||
}
|
||||
let final_step = bind select_pt_1(cx, _, select_pt_2);
|
||||
b.real_binders.insert(
|
||||
istr::from_estr(id), compose_sels(s, final_step));
|
||||
id, compose_sels(s, final_step));
|
||||
}
|
||||
none. { no_des(cx, pth.span, "under `#<>`"); }
|
||||
}
|
||||
|
|
@ -604,7 +603,7 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
|
|||
}
|
||||
}
|
||||
let final_step = bind select_pt_1(cx, _, select_pt_2);
|
||||
b.real_binders.insert(istr::from_estr(id),
|
||||
b.real_binders.insert(id,
|
||||
compose_sels(s, final_step));
|
||||
}
|
||||
none. { no_des(cx, blk.span, "under `#{}`"); }
|
||||
|
|
@ -700,7 +699,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
|
|||
}
|
||||
};
|
||||
|
||||
let macro_name: option::t<str> = none;
|
||||
let macro_name: option::t<istr> = none;
|
||||
let clauses: [@clause] = [];
|
||||
for arg: @expr in args {
|
||||
alt arg.node {
|
||||
|
|
@ -760,7 +759,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
|
|||
|
||||
ret {ident:
|
||||
alt macro_name {
|
||||
some(id) { id }
|
||||
some(id) { istr::to_estr(id) }
|
||||
none. {
|
||||
cx.span_fatal(sp,
|
||||
"macro definition must have " +
|
||||
|
|
|
|||
|
|
@ -47,13 +47,18 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
|
|||
items: &mutable [@ast::item]) {
|
||||
alt cdir.node {
|
||||
ast::cdir_src_mod(id, file_opt, attrs) {
|
||||
let file_path = id + ".rs";
|
||||
alt file_opt { some(f) { file_path = f; } none. { } }
|
||||
let file_path = id + ~".rs";
|
||||
alt file_opt {
|
||||
some(f) {
|
||||
file_path = istr::from_estr(f);
|
||||
}
|
||||
none. { }
|
||||
}
|
||||
let full_path = if std::fs::path_is_absolute(
|
||||
istr::from_estr(file_path)) {
|
||||
file_path
|
||||
file_path) {
|
||||
istr::to_estr(file_path)
|
||||
} else {
|
||||
prefix + istr::to_estr(std::fs::path_sep()) + file_path
|
||||
prefix + istr::to_estr(std::fs::path_sep() + file_path)
|
||||
};
|
||||
if cx.mode == mode_depend { cx.deps += [full_path]; ret; }
|
||||
let p0 =
|
||||
|
|
@ -74,11 +79,18 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
|
|||
}
|
||||
ast::cdir_dir_mod(id, dir_opt, cdirs, attrs) {
|
||||
let path = id;
|
||||
alt dir_opt { some(d) { path = d; } none. { } }
|
||||
alt dir_opt {
|
||||
some(d) {
|
||||
path = istr::from_estr(d);
|
||||
}
|
||||
none. { }
|
||||
}
|
||||
let full_path =
|
||||
if std::fs::path_is_absolute(istr::from_estr(path)) {
|
||||
path
|
||||
} else { prefix + istr::to_estr(std::fs::path_sep()) + path };
|
||||
if std::fs::path_is_absolute(path) {
|
||||
istr::to_estr(path)
|
||||
} else {
|
||||
prefix + istr::to_estr(std::fs::path_sep() + path)
|
||||
};
|
||||
let m0 = eval_crate_directives_to_mod(cx, cdirs, full_path);
|
||||
let i =
|
||||
@{ident: id,
|
||||
|
|
|
|||
|
|
@ -229,7 +229,10 @@ fn spanned<@T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
|
|||
|
||||
fn parse_ident(p: &parser) -> ast::ident {
|
||||
alt p.peek() {
|
||||
token::IDENT(i, _) { p.bump(); ret p.get_str(i); }
|
||||
token::IDENT(i, _) {
|
||||
p.bump();
|
||||
ret istr::from_estr(p.get_str(i));
|
||||
}
|
||||
_ { p.fatal("expecting ident"); }
|
||||
}
|
||||
}
|
||||
|
|
@ -375,7 +378,8 @@ fn parse_ty_field(p: &parser) -> ast::ty_field {
|
|||
fn ident_index(p: &parser, args: &[ast::arg], i: &ast::ident) -> uint {
|
||||
let j = 0u;
|
||||
for a: ast::arg in args { if a.ident == i { ret j; } j += 1u; }
|
||||
p.fatal("Unbound variable " + i + " in constraint arg");
|
||||
p.fatal("Unbound variable " +
|
||||
istr::to_estr(i) + " in constraint arg");
|
||||
}
|
||||
|
||||
fn parse_type_constr_arg(p: &parser) -> @ast::ty_constr_arg {
|
||||
|
|
@ -742,7 +746,7 @@ fn parse_path(p: &parser) -> ast::path {
|
|||
alt p.peek() {
|
||||
token::IDENT(i, _) {
|
||||
hi = p.get_hi_pos();
|
||||
ids += [p.get_str(i)];
|
||||
ids += [istr::from_estr(p.get_str(i))];
|
||||
hi = p.get_hi_pos();
|
||||
p.bump();
|
||||
if p.peek() == token::MOD_SEP && p.look_ahead(1u) != token::LT {
|
||||
|
|
@ -1102,7 +1106,9 @@ fn parse_dot_or_call_expr_with(p: &parser, e: @ast::expr) -> @ast::expr {
|
|||
token::IDENT(i, _) {
|
||||
hi = p.get_hi_pos();
|
||||
p.bump();
|
||||
e = mk_expr(p, lo, hi, ast::expr_field(e, p.get_str(i)));
|
||||
e = mk_expr(p, lo, hi,
|
||||
ast::expr_field(
|
||||
e, istr::from_estr(p.get_str(i))));
|
||||
}
|
||||
t { unexpected(p, t); }
|
||||
}
|
||||
|
|
@ -1455,9 +1461,9 @@ fn parse_pat(p: &parser) -> @ast::pat {
|
|||
p.bump();
|
||||
subpat = parse_pat(p);
|
||||
} else {
|
||||
if p.get_bad_expr_words()
|
||||
.contains_key(istr::from_estr(fieldname)) {
|
||||
p.fatal("found " + fieldname + " in binding position");
|
||||
if p.get_bad_expr_words().contains_key(fieldname) {
|
||||
p.fatal("found " + istr::to_estr(fieldname)
|
||||
+ " in binding position");
|
||||
}
|
||||
subpat =
|
||||
@{id: p.get_id(),
|
||||
|
|
@ -1984,7 +1990,8 @@ fn parse_native_item(p: &parser, attrs: &[ast::attribute]) ->
|
|||
} else { unexpected(p, p.peek()); }
|
||||
}
|
||||
|
||||
fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
|
||||
fn parse_native_mod_items(p: &parser, native_name: &str,
|
||||
abi: ast::native_abi,
|
||||
first_item_attrs: &[ast::attribute]) ->
|
||||
ast::native_mod {
|
||||
// Shouldn't be any view items since we've already parsed an item attr
|
||||
|
|
@ -2027,7 +2034,7 @@ fn parse_item_native_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
|
|||
if p.peek() == token::EQ {
|
||||
expect(p, token::EQ);
|
||||
native_name = parse_str(p);
|
||||
} else { native_name = id; }
|
||||
} else { native_name = istr::to_estr(id); }
|
||||
expect(p, token::LBRACE);
|
||||
let more_attrs = parse_inner_attrs_and_next(p);
|
||||
let inner_attrs = more_attrs.inner;
|
||||
|
|
@ -2062,8 +2069,9 @@ fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
|
|||
let variants: [ast::variant] = [];
|
||||
// Newtype syntax
|
||||
if p.peek() == token::EQ {
|
||||
if p.get_bad_expr_words().contains_key(istr::from_estr(id)) {
|
||||
p.fatal("found " + id + " in tag constructor position");
|
||||
if p.get_bad_expr_words().contains_key(id) {
|
||||
p.fatal("found " + istr::to_estr(id)
|
||||
+ " in tag constructor position");
|
||||
}
|
||||
p.bump();
|
||||
let ty = parse_ty(p, false);
|
||||
|
|
@ -2100,7 +2108,8 @@ fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
|
|||
}
|
||||
expect(p, token::SEMI);
|
||||
p.get_id();
|
||||
let vr = {name: p.get_str(name), args: args, id: p.get_id()};
|
||||
let vr = {name: istr::from_estr(p.get_str(name)),
|
||||
args: args, id: p.get_id()};
|
||||
variants += [spanned(vlo, vhi, vr)];
|
||||
}
|
||||
token::RBRACE. {/* empty */ }
|
||||
|
|
@ -2261,7 +2270,7 @@ fn parse_use(p: &parser) -> ast::view_item_ {
|
|||
ret ast::view_item_use(ident, metadata, p.get_id());
|
||||
}
|
||||
|
||||
fn parse_rest_import_name(p: &parser, first: ast::ident,
|
||||
fn parse_rest_import_name(p: &parser, first: &ast::ident,
|
||||
def_ident: option::t<ast::ident>) ->
|
||||
ast::view_item_ {
|
||||
let identifiers: [ast::ident] = [first];
|
||||
|
|
@ -2336,12 +2345,13 @@ fn parse_rest_import_name(p: &parser, first: ast::ident,
|
|||
}
|
||||
}
|
||||
|
||||
fn parse_full_import_name(p: &parser, def_ident: ast::ident) ->
|
||||
fn parse_full_import_name(p: &parser, def_ident: &ast::ident) ->
|
||||
ast::view_item_ {
|
||||
alt p.peek() {
|
||||
token::IDENT(i, _) {
|
||||
p.bump();
|
||||
ret parse_rest_import_name(p, p.get_str(i), some(def_ident));
|
||||
ret parse_rest_import_name(
|
||||
p, istr::from_estr(p.get_str(i)), some(def_ident));
|
||||
}
|
||||
_ { p.fatal("expecting an identifier"); }
|
||||
}
|
||||
|
|
@ -2354,9 +2364,12 @@ fn parse_import(p: &parser) -> ast::view_item_ {
|
|||
alt p.peek() {
|
||||
token::EQ. {
|
||||
p.bump();
|
||||
ret parse_full_import_name(p, p.get_str(i));
|
||||
ret parse_full_import_name(p, istr::from_estr(p.get_str(i)));
|
||||
}
|
||||
_ {
|
||||
ret parse_rest_import_name(
|
||||
p, istr::from_estr(p.get_str(i)), none);
|
||||
}
|
||||
_ { ret parse_rest_import_name(p, p.get_str(i), none); }
|
||||
}
|
||||
}
|
||||
_ { p.fatal("expecting an identifier"); }
|
||||
|
|
@ -2436,7 +2449,7 @@ fn parse_crate_mod(p: &parser, _cfg: &ast::crate_cfg) -> @ast::crate {
|
|||
config: p.get_cfg()});
|
||||
}
|
||||
|
||||
fn parse_str(p: &parser) -> ast::ident {
|
||||
fn parse_str(p: &parser) -> str {
|
||||
alt p.peek() {
|
||||
token::LIT_STR(s) { p.bump(); ret p.get_str(s); }
|
||||
_ { fail; }
|
||||
|
|
|
|||
|
|
@ -107,7 +107,8 @@ fn path_to_str(p: &ast::path) -> str {
|
|||
be to_str(p, bind print_path(_, _, false));
|
||||
}
|
||||
|
||||
fn fun_to_str(f: &ast::_fn, name: str, params: &[ast::ty_param]) -> str {
|
||||
fn fun_to_str(f: &ast::_fn, name: &ast::ident,
|
||||
params: &[ast::ty_param]) -> str {
|
||||
let writer = io::string_writer();
|
||||
let s = rust_printer(writer.get_writer());
|
||||
print_fn(s, f.decl, f.proto, name, params, f.decl.constraints);
|
||||
|
|
@ -305,7 +306,7 @@ fn print_type(s: &ps, ty: &@ast::ty) {
|
|||
fn print_field(s: &ps, f: &ast::ty_field) {
|
||||
cbox(s, indent_unit);
|
||||
print_mutability(s, f.node.mt.mut);
|
||||
word(s.s, f.node.ident);
|
||||
word(s.s, istr::to_estr(f.node.ident));
|
||||
word_space(s, ":");
|
||||
print_type(s, f.node.mt.ty);
|
||||
end(s);
|
||||
|
|
@ -320,7 +321,7 @@ fn print_type(s: &ps, ty: &@ast::ty) {
|
|||
pclose(s);
|
||||
}
|
||||
ast::ty_fn(proto, inputs, output, cf, constrs) {
|
||||
print_ty_fn(s, proto, none::<str>, inputs, output, cf, constrs);
|
||||
print_ty_fn(s, proto, none::<istr>, inputs, output, cf, constrs);
|
||||
}
|
||||
ast::ty_obj(methods) {
|
||||
head(s, "obj");
|
||||
|
|
@ -356,7 +357,7 @@ fn print_native_item(s: &ps, item: &@ast::native_item) {
|
|||
ibox(s, indent_unit);
|
||||
ibox(s, 0u);
|
||||
word_nbsp(s, "type");
|
||||
word(s.s, item.ident);
|
||||
word(s.s, istr::to_estr(item.ident));
|
||||
end(s); // end the inner ibox
|
||||
word(s.s, ";");
|
||||
end(s); // end the outer ibox
|
||||
|
|
@ -388,7 +389,7 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
alt item.node {
|
||||
ast::item_const(ty, expr) {
|
||||
head(s, "const");
|
||||
word_space(s, item.ident + ":");
|
||||
word_space(s, istr::to_estr(item.ident) + ":");
|
||||
print_type(s, ty);
|
||||
space(s.s);
|
||||
end(s); // end the head-ibox
|
||||
|
|
@ -407,7 +408,7 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
}
|
||||
ast::item_mod(_mod) {
|
||||
head(s, "mod");
|
||||
word_nbsp(s, item.ident);
|
||||
word_nbsp(s, istr::to_estr(item.ident));
|
||||
bopen(s);
|
||||
print_mod(s, _mod, item.attrs);
|
||||
bclose(s, item.span);
|
||||
|
|
@ -424,8 +425,8 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
ast::native_abi_x86stdcall. { word_nbsp(s, "\"x86stdcall\""); }
|
||||
}
|
||||
word_nbsp(s, "mod");
|
||||
word_nbsp(s, item.ident);
|
||||
if !str::eq(nmod.native_name, item.ident) {
|
||||
word_nbsp(s, istr::to_estr(item.ident));
|
||||
if !str::eq(nmod.native_name, istr::to_estr(item.ident)) {
|
||||
word_space(s, "=");
|
||||
print_string(s, nmod.native_name);
|
||||
nbsp(s);
|
||||
|
|
@ -438,7 +439,7 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
ibox(s, indent_unit);
|
||||
ibox(s, 0u);
|
||||
word_nbsp(s, "type");
|
||||
word(s.s, item.ident);
|
||||
word(s.s, istr::to_estr(item.ident));
|
||||
print_type_params(s, params);
|
||||
end(s); // end the inner ibox
|
||||
|
||||
|
|
@ -451,13 +452,13 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
ast::item_tag(variants, params) {
|
||||
let newtype =
|
||||
vec::len(variants) == 1u &&
|
||||
str::eq(item.ident, variants[0].node.name) &&
|
||||
istr::eq(item.ident, variants[0].node.name) &&
|
||||
vec::len(variants[0].node.args) == 1u;
|
||||
if newtype {
|
||||
ibox(s, indent_unit);
|
||||
word_space(s, "tag");
|
||||
} else { head(s, "tag"); }
|
||||
word(s.s, item.ident);
|
||||
word(s.s, istr::to_estr(item.ident));
|
||||
print_type_params(s, params);
|
||||
space(s.s);
|
||||
if newtype {
|
||||
|
|
@ -470,7 +471,7 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
for v: ast::variant in variants {
|
||||
space_if_not_bol(s);
|
||||
maybe_print_comment(s, v.span.lo);
|
||||
word(s.s, v.node.name);
|
||||
word(s.s, istr::to_estr(v.node.name));
|
||||
if vec::len(v.node.args) > 0u {
|
||||
popen(s);
|
||||
fn print_variant_arg(s: &ps, arg: &ast::variant_arg) {
|
||||
|
|
@ -487,13 +488,13 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
}
|
||||
ast::item_obj(_obj, params, _) {
|
||||
head(s, "obj");
|
||||
word(s.s, item.ident);
|
||||
word(s.s, istr::to_estr(item.ident));
|
||||
print_type_params(s, params);
|
||||
popen(s);
|
||||
fn print_field(s: &ps, field: &ast::obj_field) {
|
||||
ibox(s, indent_unit);
|
||||
print_mutability(s, field.mut);
|
||||
word_space(s, field.ident + ":");
|
||||
word_space(s, istr::to_estr(field.ident) + ":");
|
||||
print_type(s, field.ty);
|
||||
end(s);
|
||||
}
|
||||
|
|
@ -515,10 +516,10 @@ fn print_item(s: &ps, item: &@ast::item) {
|
|||
}
|
||||
ast::item_res(dt, dt_id, tps, ct_id) {
|
||||
head(s, "resource");
|
||||
word(s.s, item.ident);
|
||||
word(s.s, istr::to_estr(item.ident));
|
||||
print_type_params(s, tps);
|
||||
popen(s);
|
||||
word_space(s, dt.decl.inputs[0].ident + ":");
|
||||
word_space(s, istr::to_estr(dt.decl.inputs[0].ident) + ":");
|
||||
print_type(s, dt.decl.inputs[0].ty);
|
||||
pclose(s);
|
||||
space(s.s);
|
||||
|
|
@ -786,7 +787,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
|
|||
fn print_field(s: &ps, field: &ast::field) {
|
||||
ibox(s, indent_unit);
|
||||
if field.node.mut == ast::mut { word_nbsp(s, "mutable"); }
|
||||
word(s.s, field.node.ident);
|
||||
word(s.s, istr::to_estr(field.node.ident));
|
||||
word_space(s, ":");
|
||||
print_expr(s, field.node.expr);
|
||||
end(s);
|
||||
|
|
@ -981,7 +982,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
|
|||
ast::expr_field(expr, id) {
|
||||
print_expr_parens_if_unary(s, expr);
|
||||
word(s.s, ".");
|
||||
word(s.s, id);
|
||||
word(s.s, istr::to_estr(id));
|
||||
}
|
||||
ast::expr_index(expr, index) {
|
||||
print_expr_parens_if_unary(s, expr);
|
||||
|
|
@ -1042,7 +1043,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
|
|||
fn print_field(s: &ps, field: &ast::anon_obj_field) {
|
||||
ibox(s, indent_unit);
|
||||
print_mutability(s, field.mut);
|
||||
word_space(s, field.ident + ":");
|
||||
word_space(s, istr::to_estr(field.ident) + ":");
|
||||
print_type(s, field.ty);
|
||||
space(s.s);
|
||||
word_space(s, "=");
|
||||
|
|
@ -1131,7 +1132,9 @@ fn print_decl(s: &ps, decl: &@ast::decl) {
|
|||
}
|
||||
}
|
||||
|
||||
fn print_ident(s: &ps, ident: &ast::ident) { word(s.s, ident); }
|
||||
fn print_ident(s: &ps, ident: &ast::ident) {
|
||||
word(s.s, istr::to_estr(ident));
|
||||
}
|
||||
|
||||
fn print_for_decl(s: &ps, loc: &@ast::local, coll: &@ast::expr) {
|
||||
print_local_decl(s, loc);
|
||||
|
|
@ -1144,9 +1147,9 @@ fn print_path(s: &ps, path: &ast::path, colons_before_params: bool) {
|
|||
maybe_print_comment(s, path.span.lo);
|
||||
if path.node.global { word(s.s, "::"); }
|
||||
let first = true;
|
||||
for id: str in path.node.idents {
|
||||
for id: ast::ident in path.node.idents {
|
||||
if first { first = false; } else { word(s.s, "::"); }
|
||||
word(s.s, id);
|
||||
word(s.s, istr::to_estr(id));
|
||||
}
|
||||
if vec::len(path.node.types) > 0u {
|
||||
if colons_before_params { word(s.s, "::"); }
|
||||
|
|
@ -1162,7 +1165,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
|
|||
s.ann.pre(ann_node);
|
||||
alt pat.node {
|
||||
ast::pat_wild. { word(s.s, "_"); }
|
||||
ast::pat_bind(id) { word(s.s, id); }
|
||||
ast::pat_bind(id) { word(s.s, istr::to_estr(id)); }
|
||||
ast::pat_lit(lit) { print_literal(s, lit); }
|
||||
ast::pat_tag(path, args) {
|
||||
print_path(s, path, true);
|
||||
|
|
@ -1176,7 +1179,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
|
|||
word(s.s, "{");
|
||||
fn print_field(s: &ps, f: &ast::field_pat) {
|
||||
cbox(s, indent_unit);
|
||||
word(s.s, f.ident);
|
||||
word(s.s, istr::to_estr(f.ident));
|
||||
word_space(s, ":");
|
||||
print_pat(s, f.pat);
|
||||
end(s);
|
||||
|
|
@ -1199,13 +1202,13 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
|
|||
s.ann.post(ann_node);
|
||||
}
|
||||
|
||||
fn print_fn(s: &ps, decl: ast::fn_decl, proto: ast::proto, name: str,
|
||||
fn print_fn(s: &ps, decl: ast::fn_decl, proto: ast::proto, name: &ast::ident,
|
||||
typarams: &[ast::ty_param], constrs: [@ast::constr]) {
|
||||
alt decl.purity {
|
||||
ast::impure_fn. { head(s, proto_to_str(proto)); }
|
||||
_ { head(s, "pure fn"); }
|
||||
}
|
||||
word(s.s, name);
|
||||
word(s.s, istr::to_estr(name));
|
||||
print_type_params(s, typarams);
|
||||
print_fn_args_and_ret(s, decl, constrs);
|
||||
}
|
||||
|
|
@ -1215,7 +1218,7 @@ fn print_fn_args_and_ret(s: &ps, decl: &ast::fn_decl,
|
|||
popen(s);
|
||||
fn print_arg(s: &ps, x: &ast::arg) {
|
||||
ibox(s, indent_unit);
|
||||
word_space(s, x.ident + ":");
|
||||
word_space(s, istr::to_estr(x.ident) + ":");
|
||||
print_alias(s, x.mode);
|
||||
print_type(s, x.ty);
|
||||
end(s);
|
||||
|
|
@ -1236,7 +1239,7 @@ fn print_fn_block_args(s: &ps, decl: &ast::fn_decl) {
|
|||
fn print_arg(s: &ps, x: &ast::arg) {
|
||||
ibox(s, indent_unit);
|
||||
print_alias(s, x.mode);
|
||||
word(s.s, x.ident);
|
||||
word(s.s, istr::to_estr(x.ident));
|
||||
end(s);
|
||||
}
|
||||
commasep(s, inconsistent, decl.inputs, print_arg);
|
||||
|
|
@ -1266,7 +1269,7 @@ fn print_type_params(s: &ps, params: &[ast::ty_param]) {
|
|||
word(s.s, "<");
|
||||
fn printParam(s: &ps, param: &ast::ty_param) {
|
||||
print_kind(s, param.kind);
|
||||
word(s.s, param.ident);
|
||||
word(s.s, istr::to_estr(param.ident));
|
||||
}
|
||||
commasep(s, inconsistent, params, printParam);
|
||||
word(s.s, ">");
|
||||
|
|
@ -1276,14 +1279,14 @@ fn print_type_params(s: &ps, params: &[ast::ty_param]) {
|
|||
fn print_meta_item(s: &ps, item: &@ast::meta_item) {
|
||||
ibox(s, indent_unit);
|
||||
alt item.node {
|
||||
ast::meta_word(name) { word(s.s, name); }
|
||||
ast::meta_word(name) { word(s.s, istr::to_estr(name)); }
|
||||
ast::meta_name_value(name, value) {
|
||||
word_space(s, name);
|
||||
word_space(s, istr::to_estr(name));
|
||||
word_space(s, "=");
|
||||
print_literal(s, @value);
|
||||
}
|
||||
ast::meta_list(name, items) {
|
||||
word(s.s, name);
|
||||
word(s.s, istr::to_estr(name));
|
||||
popen(s);
|
||||
commasep(s, consistent, items, print_meta_item);
|
||||
pclose(s);
|
||||
|
|
@ -1298,7 +1301,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
|
|||
alt item.node {
|
||||
ast::view_item_use(id, mta, _) {
|
||||
head(s, "use");
|
||||
word(s.s, id);
|
||||
word(s.s, istr::to_estr(id));
|
||||
if vec::len(mta) > 0u {
|
||||
popen(s);
|
||||
commasep(s, consistent, mta, print_meta_item);
|
||||
|
|
@ -1307,38 +1310,43 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
|
|||
}
|
||||
ast::view_item_import(id, ids, _) {
|
||||
head(s, "import");
|
||||
if !str::eq(id, ids[vec::len(ids) - 1u]) {
|
||||
word_space(s, id);
|
||||
if !istr::eq(id, ids[vec::len(ids) - 1u]) {
|
||||
word_space(s, istr::to_estr(id));
|
||||
word_space(s, "=");
|
||||
}
|
||||
let first = true;
|
||||
for elt: str in ids {
|
||||
for elt: ast::ident in ids {
|
||||
if first { first = false; } else { word(s.s, "::"); }
|
||||
word(s.s, elt);
|
||||
word(s.s, istr::to_estr(elt));
|
||||
}
|
||||
}
|
||||
ast::view_item_import_from(mod_path, idents, _) {
|
||||
head(s, "import");
|
||||
for elt: str in mod_path { word(s.s, elt); word(s.s, "::"); }
|
||||
for elt: ast::ident in mod_path {
|
||||
word(s.s, istr::to_estr(elt)); word(s.s, "::");
|
||||
}
|
||||
word(s.s, "{");
|
||||
commasep(s, inconsistent, idents,
|
||||
fn (s: &ps, w: &ast::import_ident) {
|
||||
word(s.s, w.node.name)
|
||||
word(s.s, istr::to_estr(w.node.name))
|
||||
});
|
||||
word(s.s, "}");
|
||||
}
|
||||
ast::view_item_import_glob(ids, _) {
|
||||
head(s, "import");
|
||||
let first = true;
|
||||
for elt: str in ids {
|
||||
for elt: ast::ident in ids {
|
||||
if first { first = false; } else { word(s.s, "::"); }
|
||||
word(s.s, elt);
|
||||
word(s.s, istr::to_estr(elt));
|
||||
}
|
||||
word(s.s, "::*");
|
||||
}
|
||||
ast::view_item_export(ids, _) {
|
||||
head(s, "export");
|
||||
commasep(s, inconsistent, ids, fn (s: &ps, w: &str) { word(s.s, w) });
|
||||
commasep(s, inconsistent, ids,
|
||||
fn (s: &ps, w: &ast::ident) {
|
||||
word(s.s, istr::to_estr(w))
|
||||
});
|
||||
}
|
||||
}
|
||||
word(s.s, ";");
|
||||
|
|
@ -1402,12 +1410,18 @@ fn print_mt(s: &ps, mt: &ast::mt) {
|
|||
print_type(s, mt.ty);
|
||||
}
|
||||
|
||||
fn print_ty_fn(s: &ps, proto: &ast::proto, id: &option::t<str>,
|
||||
fn print_ty_fn(s: &ps, proto: &ast::proto, id: &option::t<ast::ident>,
|
||||
inputs: &[ast::ty_arg], output: &@ast::ty,
|
||||
cf: &ast::controlflow, constrs: &[@ast::constr]) {
|
||||
ibox(s, indent_unit);
|
||||
word(s.s, proto_to_str(proto));
|
||||
alt id { some(id) { word(s.s, " "); word(s.s, id); } _ { } }
|
||||
alt id {
|
||||
some(id) {
|
||||
word(s.s, " ");
|
||||
word(s.s, istr::to_estr(id));
|
||||
}
|
||||
_ { }
|
||||
}
|
||||
zerobreak(s.s);
|
||||
popen(s);
|
||||
fn print_arg(s: &ps, input: &ast::ty_arg) {
|
||||
|
|
@ -1680,7 +1694,7 @@ fn ast_ty_fn_constrs_str(constrs: &[@ast::constr]) -> str {
|
|||
}
|
||||
|
||||
fn fn_arg_idx_to_str(decl: &ast::fn_decl, idx: &uint) -> str {
|
||||
decl.inputs[idx].ident
|
||||
istr::to_estr(decl.inputs[idx].ident)
|
||||
}
|
||||
|
||||
fn ast_fn_constr_to_str(decl: &ast::fn_decl, c: &@ast::constr) -> str {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue