bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Improve line comment positioning

Browse source 
This involved making ast.variant spanned.
This commit is contained in:
Marijn Haverbeke 2011-03-29 12:46:55 +02:00 • committed by Graydon Hoare
parent 8a7ea941bb
commit 39f0656b4f
8 changed files with 117 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/comp/front/ast.rs
View file

@ -385,7 +385,8 @@ type native_mod = rec(str native_name,
type native_mod_index = hashmap[ident,native_mod_index_entry]; type native_mod_index = hashmap[ident,native_mod_index_entry];
type variant_arg = rec(@ty ty, def_id id); type variant_arg = rec(@ty ty, def_id id);
type variant = rec(str name, vec[variant_arg] args, def_id id, ann ann); type variant_ = rec(str name, vec[variant_arg] args, def_id id, ann ann);
type variant = spanned[variant_];
type view_item = spanned[view_item_]; type view_item = spanned[view_item_];
tag view_item_ { tag view_item_ {
@ -451,7 +452,7 @@ fn index_item(mod_index index, @item it) {
index.insert(id, ast.mie_item(it)); index.insert(id, ast.mie_item(it));
let uint variant_idx = 0u; let uint variant_idx = 0u;
for (ast.variant v in variants) { for (ast.variant v in variants) {
index.insert(v.name, index.insert(v.node.name,
ast.mie_tag_variant(it, variant_idx)); ast.mie_tag_variant(it, variant_idx));
variant_idx += 1u; variant_idx += 1u;
} }
@ -509,7 +510,7 @@ fn index_stmt(block_index index, @stmt s) {
let uint vid = 0u; let uint vid = 0u;
for (ast.variant v in variants) { for (ast.variant v in variants) {
auto t = ast.bie_tag_variant(it, vid); auto t = ast.bie_tag_variant(it, vid);
index.insert(v.name, t); index.insert(v.node.name, t);
vid += 1u; vid += 1u;
} }
} }

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

@ -451,7 +451,9 @@ impure fn parse_ty(parser p) -> @ast.ty {
} }
case (token.IDENT(_)) { case (token.IDENT(_)) {
t = ast.ty_path(parse_path(p, GREEDY), none[ast.def]); auto path = parse_path(p, GREEDY);
t = ast.ty_path(path, none[ast.def]);
hi = path.span;
} }
case (token.MUTABLE) { case (token.MUTABLE) {
@ -2067,6 +2069,7 @@ impure fn parse_item_tag(parser p) -> @ast.item {
auto tok = p.peek(); auto tok = p.peek();
alt (tok) { alt (tok) {
case (token.IDENT(?name)) { case (token.IDENT(?name)) {
auto vlo = p.get_span();
p.bump(); p.bump();
let vec[ast.variant_arg] args = vec(); let vec[ast.variant_arg] args = vec();
@ -2084,11 +2087,12 @@ impure fn parse_item_tag(parser p) -> @ast.item {
case (_) { /* empty */ } case (_) { /* empty */ }
} }
auto vhi = p.get_span();
expect(p, token.SEMI); expect(p, token.SEMI);
auto id = p.next_def_id(); auto id = p.next_def_id();
variants += vec(rec(name=name, args=args, id=id, auto vr = rec(name=name, args=args, id=id, ann=ast.ann_none);
ann=ast.ann_none)); variants += vec(spanned[ast.variant_](vlo, vhi, vr));
} }
case (token.RBRACE) { /* empty */ } case (token.RBRACE) { /* empty */ }
case (_) { case (_) {

7
src/comp/middle/fold.rs
View file

@ -965,12 +965,13 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
let vec[ast.variant] new_variants = vec(); let vec[ast.variant] new_variants = vec();
for (ast.variant v in variants) { for (ast.variant v in variants) {
let vec[ast.variant_arg] new_args = vec(); let vec[ast.variant_arg] new_args = vec();
for (ast.variant_arg va in v.args) { for (ast.variant_arg va in v.node.args) {
auto new_ty = fold_ty[ENV](env_, fld, va.ty); auto new_ty = fold_ty[ENV](env_, fld, va.ty);
new_args += vec(rec(ty=new_ty, id=va.id)); new_args += vec(rec(ty=new_ty, id=va.id));
} }
new_variants += vec(rec(name=v.name, args=new_args, id=v.id, auto new_v = rec(name=v.node.name, args=new_args,
ann=v.ann)); id=v.node.id, ann=v.node.ann);
new_variants += vec(respan[ast.variant_](v.span, new_v));
} }
ret fld.fold_item_tag(env_, i.span, ident, new_variants, ret fld.fold_item_tag(env_, i.span, ident, new_variants,
ty_params, id); ty_params, id);

14
src/comp/middle/metadata.rs
View file

@ -169,8 +169,8 @@ fn encode_def_id(&ebml.writer ebml_w, &ast.def_id id) {
fn encode_tag_variant_paths(&ebml.writer ebml_w, vec[ast.variant] variants) { fn encode_tag_variant_paths(&ebml.writer ebml_w, vec[ast.variant] variants) {
for (ast.variant variant in variants) { for (ast.variant variant in variants) {
ebml.start_tag(ebml_w, tag_paths_item); ebml.start_tag(ebml_w, tag_paths_item);
encode_name(ebml_w, variant.name); encode_name(ebml_w, variant.node.name);
encode_def_id(ebml_w, variant.id); encode_def_id(ebml_w, variant.node.id);
ebml.end_tag(ebml_w); ebml.end_tag(ebml_w);
} }
} }
@ -314,14 +314,14 @@ fn encode_tag_variant_info(@trans.crate_ctxt cx, &ebml.writer ebml_w,
ast.def_id did, vec[ast.variant] variants) { ast.def_id did, vec[ast.variant] variants) {
for (ast.variant variant in variants) { for (ast.variant variant in variants) {
ebml.start_tag(ebml_w, tag_items_item); ebml.start_tag(ebml_w, tag_items_item);
encode_def_id(ebml_w, variant.id); encode_def_id(ebml_w, variant.node.id);
encode_kind(ebml_w, 'v' as u8); encode_kind(ebml_w, 'v' as u8);
encode_tag_id(ebml_w, did); encode_tag_id(ebml_w, did);
encode_type(ebml_w, trans.node_ann_type(cx, variant.ann)); encode_type(ebml_w, trans.node_ann_type(cx, variant.node.ann));
if (_vec.len[ast.variant_arg](variant.args) > 0u) { if (_vec.len[ast.variant_arg](variant.node.args) > 0u) {
encode_symbol(cx, ebml_w, variant.id); encode_symbol(cx, ebml_w, variant.node.id);
} }
encode_discriminant(cx, ebml_w, variant.id); encode_discriminant(cx, ebml_w, variant.node.id);
ebml.end_tag(ebml_w); ebml.end_tag(ebml_w);
} }
} }

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

@ -389,7 +389,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns)
case (ast.mie_tag_variant(?item, ?variant_idx)) { case (ast.mie_tag_variant(?item, ?variant_idx)) {
alt (item.node) { alt (item.node) {
case (ast.item_tag(_, ?variants, _, ?tid)) { case (ast.item_tag(_, ?variants, _, ?tid)) {
auto vid = variants.(variant_idx).id; auto vid = variants.(variant_idx).node.id;
auto t = ast.def_variant(tid, vid); auto t = ast.def_variant(tid, vid);
ret some[def_wrap](def_wrap_other(t)); ret some[def_wrap](def_wrap_other(t));
} }
@ -446,7 +446,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns)
fn found_tag(@ast.item item, uint variant_idx) -> def_wrap { fn found_tag(@ast.item item, uint variant_idx) -> def_wrap {
alt (item.node) { alt (item.node) {
case (ast.item_tag(_, ?variants, _, ?tid)) { case (ast.item_tag(_, ?variants, _, ?tid)) {
auto vid = variants.(variant_idx).id; auto vid = variants.(variant_idx).node.id;
auto t = ast.def_variant(tid, vid); auto t = ast.def_variant(tid, vid);
ret def_wrap_other(t); ret def_wrap_other(t);
} }

47
src/comp/middle/trans.rs
View file

@ -1355,7 +1355,7 @@ fn GEP_tag(@block_ctxt cx,
// Synthesize a tuple type so that GEP_tup_like() can work its magic. // Synthesize a tuple type so that GEP_tup_like() can work its magic.
// Separately, store the type of the element we're interested in. // Separately, store the type of the element we're interested in.
auto arg_tys = arg_tys_of_fn(variant.ann); auto arg_tys = arg_tys_of_fn(variant.node.ann);
auto elem_ty = ty.plain_ty(ty.ty_nil); // typestate infelicity auto elem_ty = ty.plain_ty(ty.ty_nil); // typestate infelicity
auto i = 0; auto i = 0;
let vec[@ty.t] true_arg_tys = vec(); let vec[@ty.t] true_arg_tys = vec();
@ -1892,7 +1892,7 @@ fn decr_refcnt_and_if_zero(@block_ctxt cx,
fn variant_types(@crate_ctxt cx, &ast.variant v) -> vec[@ty.t] { fn variant_types(@crate_ctxt cx, &ast.variant v) -> vec[@ty.t] {
let vec[@ty.t] tys = vec(); let vec[@ty.t] tys = vec();
alt (ty.ann_to_type(v.ann).struct) { alt (ty.ann_to_type(v.node.ann).struct) {
case (ty.ty_fn(_, ?args, _)) { case (ty.ty_fn(_, ?args, _)) {
for (ty.arg arg in args) { for (ty.arg arg in args) {
tys += vec(arg.ty); tys += vec(arg.ty);
@ -1931,7 +1931,7 @@ fn tag_variant_with_id(@crate_ctxt cx,
auto i = 0u; auto i = 0u;
while (i < _vec.len[ast.variant](variants)) { while (i < _vec.len[ast.variant](variants)) {
auto variant = variants.(i); auto variant = variants.(i);
if (common.def_eq(variant.id, variant_id)) { if (common.def_eq(variant.node.id, variant_id)) {
ret variant; ret variant;
} }
i += 1u; i += 1u;
@ -2074,9 +2074,9 @@ fn iter_structural_ty_full(@block_ctxt cx,
_uint.to_str(i, 10u)); _uint.to_str(i, 10u));
llvm.LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb); llvm.LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb);
if (_vec.len[ast.variant_arg](variant.args) > 0u) { if (_vec.len[ast.variant_arg](variant.node.args) > 0u) {
// N-ary variant. // N-ary variant.
auto fn_ty = ty.ann_to_type(variants.(i).ann); auto fn_ty = ty.ann_to_type(variants.(i).node.ann);
alt (fn_ty.struct) { alt (fn_ty.struct) {
case (ty.ty_fn(_, ?args, _)) { case (ty.ty_fn(_, ?args, _)) {
auto j = 0; auto j = 0;
@ -2084,12 +2084,12 @@ fn iter_structural_ty_full(@block_ctxt cx,
auto v = vec(C_int(0), C_int(j as int)); auto v = vec(C_int(0), C_int(j as int));
auto rslt = GEP_tag(variant_cx, llunion_a_ptr, auto rslt = GEP_tag(variant_cx, llunion_a_ptr,
tid, variants.(i).id, tps, j); tid, variants.(i).node.id, tps, j);
auto llfldp_a = rslt.val; auto llfldp_a = rslt.val;
variant_cx = rslt.bcx; variant_cx = rslt.bcx;
rslt = GEP_tag(variant_cx, llunion_b_ptr, tid, rslt = GEP_tag(variant_cx, llunion_b_ptr, tid,
variants.(i).id, tps, j); variants.(i).node.id, tps, j);
auto llfldp_b = rslt.val; auto llfldp_b = rslt.val;
variant_cx = rslt.bcx; variant_cx = rslt.bcx;
@ -3436,7 +3436,7 @@ fn trans_pat_match(@block_ctxt cx, @ast.pat pat, ValueRef llval,
auto variants = tag_variants(cx.fcx.ccx, vdef._0); auto variants = tag_variants(cx.fcx.ccx, vdef._0);
auto i = 0; auto i = 0;
for (ast.variant v in variants) { for (ast.variant v in variants) {
auto this_variant_id = v.id; auto this_variant_id = v.node.id;
if (variant_id._0 == this_variant_id._0 && if (variant_id._0 == this_variant_id._0 &&
variant_id._1 == this_variant_id._1) { variant_id._1 == this_variant_id._1) {
variant_tag = i; variant_tag = i;
@ -3698,9 +3698,9 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
alt (tag_item.node) { alt (tag_item.node) {
case (ast.item_tag(_, ?variants, _, _)) { case (ast.item_tag(_, ?variants, _, _)) {
for (ast.variant v in variants) { for (ast.variant v in variants) {
if (v.id == vid) { if (v.node.id == vid) {
fty = node_ann_type(cx.fcx.ccx, fty = node_ann_type(cx.fcx.ccx,
v.ann); v.node.ann);
} }
} }
} }
@ -5731,27 +5731,27 @@ fn trans_obj(@crate_ctxt cx, &ast._obj ob, ast.def_id oid,
fn trans_tag_variant(@crate_ctxt cx, ast.def_id tag_id, fn trans_tag_variant(@crate_ctxt cx, ast.def_id tag_id,
&ast.variant variant, int index, &ast.variant variant, int index,
&vec[ast.ty_param] ty_params) { &vec[ast.ty_param] ty_params) {
if (_vec.len[ast.variant_arg](variant.args) == 0u) { if (_vec.len[ast.variant_arg](variant.node.args) == 0u) {
ret; // nullary constructors are just constants ret; // nullary constructors are just constants
} }
// Translate variant arguments to function arguments. // Translate variant arguments to function arguments.
let vec[ast.arg] fn_args = vec(); let vec[ast.arg] fn_args = vec();
auto i = 0u; auto i = 0u;
for (ast.variant_arg varg in variant.args) { for (ast.variant_arg varg in variant.node.args) {
fn_args += vec(rec(mode=ast.alias, fn_args += vec(rec(mode=ast.alias,
ty=varg.ty, ty=varg.ty,
ident="arg" + _uint.to_str(i, 10u), ident="arg" + _uint.to_str(i, 10u),
id=varg.id)); id=varg.id));
} }
check (cx.item_ids.contains_key(variant.id)); check (cx.item_ids.contains_key(variant.node.id));
let ValueRef llfndecl = cx.item_ids.get(variant.id); let ValueRef llfndecl = cx.item_ids.get(variant.node.id);
auto fcx = new_fn_ctxt(cx, llfndecl); auto fcx = new_fn_ctxt(cx, llfndecl);
create_llargs_for_fn_args(fcx, ast.proto_fn, create_llargs_for_fn_args(fcx, ast.proto_fn,
none[TypeRef], ret_ty_of_fn(variant.ann), none[TypeRef], ret_ty_of_fn(variant.node.ann),
fn_args, ty_params); fn_args, ty_params);
let vec[@ty.t] ty_param_substs = vec(); let vec[@ty.t] ty_param_substs = vec();
@ -5759,7 +5759,7 @@ fn trans_tag_variant(@crate_ctxt cx, ast.def_id tag_id,
ty_param_substs += vec(plain_ty(ty.ty_param(tp.id))); ty_param_substs += vec(plain_ty(ty.ty_param(tp.id)));
} }
auto arg_tys = arg_tys_of_fn(variant.ann); auto arg_tys = arg_tys_of_fn(variant.node.ann);
copy_args_to_allocas(fcx, fn_args, arg_tys); copy_args_to_allocas(fcx, fn_args, arg_tys);
auto bcx = new_top_block_ctxt(fcx); auto bcx = new_top_block_ctxt(fcx);
@ -5777,8 +5777,8 @@ fn trans_tag_variant(@crate_ctxt cx, ast.def_id tag_id,
vec(C_int(0), C_int(1))); vec(C_int(0), C_int(1)));
i = 0u; i = 0u;
for (ast.variant_arg va in variant.args) { for (ast.variant_arg va in variant.node.args) {
auto rslt = GEP_tag(bcx, llblobptr, tag_id, variant.id, auto rslt = GEP_tag(bcx, llblobptr, tag_id, variant.node.id,
ty_param_substs, i as int); ty_param_substs, i as int);
bcx = rslt.bcx; bcx = rslt.bcx;
auto lldestptr = rslt.val; auto lldestptr = rslt.val;
@ -6182,9 +6182,10 @@ fn collect_tag_ctor(&@crate_ctxt cx, @ast.item i) -> @crate_ctxt {
case (ast.item_tag(_, ?variants, ?tps, _)) { case (ast.item_tag(_, ?variants, ?tps, _)) {
for (ast.variant variant in variants) { for (ast.variant variant in variants) {
if (_vec.len[ast.variant_arg](variant.args) != 0u) { if (_vec.len[ast.variant_arg](variant.node.args) != 0u) {
decl_fn_and_pair(extend_path(cx, variant.name), "tag", decl_fn_and_pair(extend_path(cx, variant.node.name),
tps, variant.ann, variant.id); "tag", tps, variant.node.ann,
variant.node.id);
} }
} }
} }
@ -6229,8 +6230,8 @@ fn trans_constant(&@crate_ctxt cx, @ast.item it) -> @crate_ctxt {
llvm.LLVMSetLinkage(discrim_gvar, lib.llvm.LLVMPrivateLinkage llvm.LLVMSetLinkage(discrim_gvar, lib.llvm.LLVMPrivateLinkage
as llvm.Linkage); as llvm.Linkage);
cx.discrims.insert(variant.id, discrim_gvar); cx.discrims.insert(variant.node.id, discrim_gvar);
cx.discrim_symbols.insert(variant.id, s); cx.discrim_symbols.insert(variant.node.id, s);
i += 1u; i += 1u;
} }

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

@ -656,7 +656,7 @@ fn collect_item_types(session.session sess, @ast.crate crate)
// Nullary tag constructors get turned into constants; n-ary tag // Nullary tag constructors get turned into constants; n-ary tag
// constructors get turned into functions. // constructors get turned into functions.
auto result_ty; auto result_ty;
if (_vec.len[ast.variant_arg](variant.args) == 0u) { if (_vec.len[ast.variant_arg](variant.node.args) == 0u) {
result_ty = plain_ty(ty.ty_tag(tag_id, ty_param_tys)); result_ty = plain_ty(ty.ty_tag(tag_id, ty_param_tys));
} else { } else {
// As above, tell ast_ty_to_ty() that trans_ty_item_to_ty() // As above, tell ast_ty_to_ty() that trans_ty_item_to_ty()
@ -664,7 +664,7 @@ fn collect_item_types(session.session sess, @ast.crate crate)
auto f = bind getter(sess, id_to_ty_item, type_cache, _); auto f = bind getter(sess, id_to_ty_item, type_cache, _);
let vec[arg] args = vec(); let vec[arg] args = vec();
for (ast.variant_arg va in variant.args) { for (ast.variant_arg va in variant.node.args) {
auto arg_ty = ast_ty_to_ty(f, va.ty); auto arg_ty = ast_ty_to_ty(f, va.ty);
args += vec(rec(mode=ast.alias, ty=arg_ty)); args += vec(rec(mode=ast.alias, ty=arg_ty));
} }
@ -673,13 +673,13 @@ fn collect_item_types(session.session sess, @ast.crate crate)
} }
auto tpt = tup(params_opt, result_ty); auto tpt = tup(params_opt, result_ty);
type_cache.insert(variant.id, tpt); type_cache.insert(variant.node.id, tpt);
auto variant_t = rec( auto variant_t = rec(
ann=ast.ann_type(result_ty, none[vec[@ty.t]]) ann=ast.ann_type(result_ty, none[vec[@ty.t]])
with variant with variant.node
); );
result += vec(variant_t); result += vec(fold.respan[ast.variant_](variant.span, variant_t));
} }
ret result; ret result;

91
src/comp/pretty/pprust.rs
View file

@ -4,6 +4,7 @@ import std.io;
import std.option; import std.option;
import front.ast; import front.ast;
import front.lexer; import front.lexer;
import util.common;
import pp.end; import pp.wrd; import pp.space; import pp.line; import pp.end; import pp.wrd; import pp.space; import pp.line;
const uint indent_unit = 4u; const uint indent_unit = 4u;
@ -59,11 +60,11 @@ impure fn bclose(ps s) {
end(s.s); end(s.s);
pp.cwrd(s.s, "}"); pp.cwrd(s.s, "}");
} }
impure fn bclose_c(ps s, util.common.span span) { impure fn bclose_c(ps s, common.span span) {
maybe_print_comment(s, span.hi); maybe_print_comment(s, span.hi);
bclose(s); bclose(s);
} }
impure fn commasep[IN](ps s, vec[IN] elts, impure fn (ps, &IN) op) { impure fn commasep[IN](ps s, vec[IN] elts, impure fn(ps, &IN) op) {
auto first = true; auto first = true;
for (IN elt in elts) { for (IN elt in elts) {
if (first) {first = false;} if (first) {first = false;}
@ -71,6 +72,25 @@ impure fn commasep[IN](ps s, vec[IN] elts, impure fn (ps, &IN) op) {
op(s, elt); op(s, elt);
} }
} }
impure fn commasep_cmnt[IN](ps s, vec[IN] elts, impure fn(ps, &IN) op,
fn(&IN) -> common.span get_span) {
auto len = _vec.len[IN](elts);
auto i = 0u;
for (IN elt in elts) {
op(s, elt);
i += 1u;
if (i < len) {
wrd(s.s, ",");
if (!maybe_print_line_comment(s, get_span(elt))) {space(s.s);}
}
}
}
impure fn commasep_exprs(ps s, vec[@ast.expr] exprs) {
fn expr_span(&@ast.expr expr) -> common.span {ret expr.span;}
auto f = print_expr;
auto gs = expr_span;
commasep_cmnt[@ast.expr](s, exprs, f, gs);
}
impure fn print_mod(ps s, ast._mod _mod) { impure fn print_mod(ps s, ast._mod _mod) {
for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);} for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);}
@ -87,7 +107,7 @@ impure fn print_type(ps s, &@ast.ty ty) {
case (ast.ty_bool) {wrd(s.s, "bool");} case (ast.ty_bool) {wrd(s.s, "bool");}
case (ast.ty_int) {wrd(s.s, "int");} case (ast.ty_int) {wrd(s.s, "int");}
case (ast.ty_uint) {wrd(s.s, "uint");} case (ast.ty_uint) {wrd(s.s, "uint");}
case (ast.ty_machine(?tm)) {wrd(s.s, util.common.ty_mach_to_str(tm));} case (ast.ty_machine(?tm)) {wrd(s.s, common.ty_mach_to_str(tm));}
case (ast.ty_char) {wrd(s.s, "char");} case (ast.ty_char) {wrd(s.s, "char");}
case (ast.ty_str) {wrd(s.s, "str");} case (ast.ty_str) {wrd(s.s, "str");}
case (ast.ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);} case (ast.ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
@ -118,8 +138,16 @@ impure fn print_type(ps s, &@ast.ty ty) {
wrd(s.s, f.ident); wrd(s.s, f.ident);
end(s.s); end(s.s);
} }
fn get_span(&ast.ty_field f) -> common.span {
// Try to reconstruct the span for this field
auto sp = f.mt.ty.span;
auto hi = rec(line=sp.hi.line,
col=sp.hi.col + _str.char_len(f.ident) + 1u);
ret rec(hi=hi with sp);
}
auto f = print_field; auto f = print_field;
commasep[ast.ty_field](s, fields, f); auto gs = get_span;
commasep_cmnt[ast.ty_field](s, fields, f, gs);
pclose(s); pclose(s);
} }
case (ast.ty_obj(?methods)) { case (ast.ty_obj(?methods)) {
@ -219,18 +247,19 @@ impure fn print_item(ps s, @ast.item item) {
space(s.s); space(s.s);
bopen(s); bopen(s);
for (ast.variant v in variants) { for (ast.variant v in variants) {
wrd(s.s, v.name); maybe_print_comment(s, v.span.lo);
if (_vec.len[ast.variant_arg](v.args) > 0u) { wrd(s.s, v.node.name);
if (_vec.len[ast.variant_arg](v.node.args) > 0u) {
popen(s); popen(s);
impure fn print_variant_arg(ps s, &ast.variant_arg arg) { impure fn print_variant_arg(ps s, &ast.variant_arg arg) {
print_type(s, arg.ty); print_type(s, arg.ty);
} }
auto f = print_variant_arg; auto f = print_variant_arg;
commasep[ast.variant_arg](s, v.args, f); commasep[ast.variant_arg](s, v.node.args, f);
pclose(s); pclose(s);
} }
wrd(s.s, ";"); wrd(s.s, ";");
line(s.s); if (!maybe_print_line_comment(s, v.span)) {line(s.s);}
} }
bclose_c(s, item.span); bclose_c(s, item.span);
} }
@ -246,8 +275,10 @@ impure fn print_item(ps s, @ast.item item) {
wrd(s.s, field.ident); wrd(s.s, field.ident);
end(s.s); end(s.s);
} }
fn get_span(&ast.obj_field f) -> common.span {ret f.ty.span;}
auto f = print_field; auto f = print_field;
commasep[ast.obj_field](s, _obj.fields, f); auto gs = get_span;
commasep_cmnt[ast.obj_field](s, _obj.fields, f, gs);
pclose(s); pclose(s);
space(s.s); space(s.s);
bopen(s); bopen(s);
@ -284,25 +315,25 @@ impure fn print_block(ps s, ast.block blk) {
maybe_print_comment(s, blk.span.lo); maybe_print_comment(s, blk.span.lo);
bopen(s); bopen(s);
for (@ast.stmt st in blk.node.stmts) { for (@ast.stmt st in blk.node.stmts) {
if (cur_line != 0u && blk.span.lo.line > cur_line + 1u) { if (cur_line != 0u && st.span.lo.line > cur_line + 1u) {
line(s.s); line(s.s);
} }
cur_line = blk.span.hi.line; cur_line = st.span.hi.line;
maybe_print_comment(s, st.span.lo); maybe_print_comment(s, st.span.lo);
alt (st.node) { alt (st.node) {
case (ast.stmt_decl(?decl)) {print_decl(s, decl);} case (ast.stmt_decl(?decl)) {print_decl(s, decl);}
case (ast.stmt_expr(?expr)) {print_expr(s, expr);} case (ast.stmt_expr(?expr)) {print_expr(s, expr);}
} }
if (front.parser.stmt_ends_with_semi(st)) {wrd(s.s, ";");} if (front.parser.stmt_ends_with_semi(st)) {wrd(s.s, ";");}
if (!maybe_print_stmt_comment(s, st.span)) {line(s.s);} if (!maybe_print_line_comment(s, st.span)) {line(s.s);}
} }
alt (blk.node.expr) { alt (blk.node.expr) {
case (option.some[@ast.expr](?expr)) { case (option.some[@ast.expr](?expr)) {
if (cur_line != 0u && blk.span.lo.line > cur_line + 1u) { if (cur_line != 0u && expr.span.lo.line > cur_line + 1u) {
line(s.s); line(s.s);
} }
print_expr(s, expr); print_expr(s, expr);
if (!maybe_print_stmt_comment(s, expr.span)) {line(s.s);} if (!maybe_print_line_comment(s, expr.span)) {line(s.s);}
} }
case (_) {} case (_) {}
} }
@ -318,17 +349,17 @@ impure fn print_literal(ps s, @ast.lit lit) {
+ "'"); + "'");
} }
case (ast.lit_int(?val)) { case (ast.lit_int(?val)) {
wrd(s.s, util.common.istr(val)); wrd(s.s, common.istr(val));
} }
case (ast.lit_uint(?val)) { // FIXME clipping? uistr? case (ast.lit_uint(?val)) { // FIXME clipping? uistr?
wrd(s.s, util.common.istr(val as int) + "u"); wrd(s.s, common.istr(val as int) + "u");
} }
case (ast.lit_float(?fstr)) { case (ast.lit_float(?fstr)) {
wrd(s.s, fstr); wrd(s.s, fstr);
} }
case (ast.lit_mach_int(?mach,?val)) { case (ast.lit_mach_int(?mach,?val)) {
wrd(s.s, util.common.istr(val as int)); wrd(s.s, common.istr(val as int));
wrd(s.s, util.common.ty_mach_to_str(mach)); wrd(s.s, common.ty_mach_to_str(mach));
} }
case (ast.lit_nil) {wrd(s.s, "()");} case (ast.lit_nil) {wrd(s.s, "()");}
case (ast.lit_bool(?val)) { case (ast.lit_bool(?val)) {
@ -339,7 +370,6 @@ impure fn print_literal(ps s, @ast.lit lit) {
impure fn print_expr(ps s, &@ast.expr expr) { impure fn print_expr(ps s, &@ast.expr expr) {
maybe_print_comment(s, expr.span.lo); maybe_print_comment(s, expr.span.lo);
auto pe = print_expr;
hbox(s); hbox(s);
alt (expr.node) { alt (expr.node) {
case (ast.expr_vec(?exprs,?mut,_)) { case (ast.expr_vec(?exprs,?mut,_)) {
@ -348,7 +378,7 @@ impure fn print_expr(ps s, &@ast.expr expr) {
} }
wrd(s.s, "vec"); wrd(s.s, "vec");
popen(s); popen(s);
commasep[@ast.expr](s, exprs, pe); commasep_exprs(s, exprs);
pclose(s); pclose(s);
} }
case (ast.expr_tup(?exprs,_)) { case (ast.expr_tup(?exprs,_)) {
@ -358,10 +388,12 @@ impure fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, elt.expr); print_expr(s, elt.expr);
end(s.s); end(s.s);
} }
fn get_span(&ast.elt elt) -> common.span {ret elt.expr.span;}
wrd(s.s, "tup"); wrd(s.s, "tup");
popen(s); popen(s);
auto f = printElt; auto f = printElt;
commasep[ast.elt](s, exprs, f); auto gs = get_span;
commasep_cmnt[ast.elt](s, exprs, f, gs);
pclose(s); pclose(s);
} }
case (ast.expr_rec(?fields,?wth,_)) { case (ast.expr_rec(?fields,?wth,_)) {
@ -373,10 +405,14 @@ impure fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, field.expr); print_expr(s, field.expr);
end(s.s); end(s.s);
} }
fn get_span(&ast.field field) -> common.span {
ret field.expr.span;
}
wrd(s.s, "rec"); wrd(s.s, "rec");
popen(s); popen(s);
auto f = print_field; auto f = print_field;
commasep[ast.field](s, fields, f); auto gs = get_span;
commasep_cmnt[ast.field](s, fields, f, gs);
alt (wth) { alt (wth) {
case (option.some[@ast.expr](?expr)) { case (option.some[@ast.expr](?expr)) {
if (_vec.len[ast.field](fields) > 0u) {space(s.s);} if (_vec.len[ast.field](fields) > 0u) {space(s.s);}
@ -392,7 +428,7 @@ impure fn print_expr(ps s, &@ast.expr expr) {
case (ast.expr_call(?func,?args,_)) { case (ast.expr_call(?func,?args,_)) {
print_expr(s, func); print_expr(s, func);
popen(s); popen(s);
commasep[@ast.expr](s, args, pe); commasep_exprs(s, args);
pclose(s); pclose(s);
} }
case (ast.expr_bind(?func,?args,_)) { case (ast.expr_bind(?func,?args,_)) {
@ -598,7 +634,7 @@ impure fn print_expr(ps s, &@ast.expr expr) {
print_path(s, path); print_path(s, path);
if (_vec.len[@ast.expr](args) > 0u) { if (_vec.len[@ast.expr](args) > 0u) {
popen(s); popen(s);
commasep[@ast.expr](s, args, pe); commasep_exprs(s, args);
pclose(s); pclose(s);
} }
// FIXME: extension 'body' // FIXME: extension 'body'
@ -891,7 +927,7 @@ fn next_comment(ps s) -> option.t[lexer.cmnt] {
} }
} }
impure fn maybe_print_comment(ps s, util.common.pos pos) { impure fn maybe_print_comment(ps s, common.pos pos) {
while (true) { while (true) {
alt (next_comment(s)) { alt (next_comment(s)) {
case (option.some[lexer.cmnt](?cmnt)) { case (option.some[lexer.cmnt](?cmnt)) {
@ -907,10 +943,11 @@ impure fn maybe_print_comment(ps s, util.common.pos pos) {
} }
} }
impure fn maybe_print_stmt_comment(ps s, util.common.span span) -> bool { impure fn maybe_print_line_comment(ps s, common.span span) -> bool {
alt (next_comment(s)) { alt (next_comment(s)) {
case (option.some[lexer.cmnt](?cmnt)) { case (option.some[lexer.cmnt](?cmnt)) {
if (span.hi.line == cmnt.pos.line) { if (span.hi.line == cmnt.pos.line &&
span.hi.col + 4u >= cmnt.pos.col) {
wrd(s.s, " "); wrd(s.s, " ");
print_comment(s, cmnt.val); print_comment(s, cmnt.val);
s.cur_cmnt += 1u; s.cur_cmnt += 1u;