Improve line comment positioning

This involved making ast.variant spanned.

8 files changed, 117 insertions, 73 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 450cc933151..fae9039205d 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -385,7 +385,8 @@ type native_mod = rec(str native_name,
 type native_mod_index = hashmap[ident,native_mod_index_entry];
 
 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_];
 tag view_item_ {
@@ -451,7 +452,7 @@ fn index_item(mod_index index, @item it) {
             index.insert(id, ast.mie_item(it));
             let uint variant_idx = 0u;
             for (ast.variant v in variants) {
-                index.insert(v.name,
+                index.insert(v.node.name,
                              ast.mie_tag_variant(it, variant_idx));
                 variant_idx += 1u;
             }
@@ -509,7 +510,7 @@ fn index_stmt(block_index index, @stmt s) {
                             let uint vid = 0u;
                             for (ast.variant v in variants) {
                                 auto t = ast.bie_tag_variant(it, vid);
-                                index.insert(v.name, t);
+                                index.insert(v.node.name, t);
                                 vid += 1u;
                             }
                         }
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index cc3388b3bfa..8562c56ae7a 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -451,7 +451,9 @@ impure fn parse_ty(parser p) -> @ast.ty {
         }
 
         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) {
@@ -2067,6 +2069,7 @@ impure fn parse_item_tag(parser p) -> @ast.item {
         auto tok = p.peek();
         alt (tok) {
             case (token.IDENT(?name)) {
+                auto vlo = p.get_span();
                 p.bump();
 
                 let vec[ast.variant_arg] args = vec();
@@ -2084,11 +2087,12 @@ impure fn parse_item_tag(parser p) -> @ast.item {
                     case (_) { /* empty */ }
                 }
 
+                auto vhi = p.get_span();
                 expect(p, token.SEMI);
 
                 auto id = p.next_def_id();
-                variants += vec(rec(name=name, args=args, id=id,
-                                    ann=ast.ann_none));
+                auto vr = rec(name=name, args=args, id=id, ann=ast.ann_none);
+                variants += vec(spanned[ast.variant_](vlo, vhi, vr));
             }
             case (token.RBRACE) { /* empty */ }
             case (_) {
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index 66176d79069..0b1a01ad6b4 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -965,12 +965,13 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
             let vec[ast.variant] new_variants = vec();
             for (ast.variant v in variants) {
                 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);
                     new_args += vec(rec(ty=new_ty, id=va.id));
                 }
-                new_variants += vec(rec(name=v.name, args=new_args, id=v.id,
-                                        ann=v.ann));
+                auto new_v = rec(name=v.node.name, args=new_args,
+                                 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,
                                   ty_params, id);
diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs
index 4ace1f4ad6a..f4854733a36 100644
--- a/src/comp/middle/metadata.rs
+++ b/src/comp/middle/metadata.rs
@@ -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) {
     for (ast.variant variant in variants) {
         ebml.start_tag(ebml_w, tag_paths_item);
-        encode_name(ebml_w, variant.name);
-        encode_def_id(ebml_w, variant.id);
+        encode_name(ebml_w, variant.node.name);
+        encode_def_id(ebml_w, variant.node.id);
         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) {
     for (ast.variant variant in variants) {
         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_tag_id(ebml_w, did);
-        encode_type(ebml_w, trans.node_ann_type(cx, variant.ann));
-        if (_vec.len[ast.variant_arg](variant.args) > 0u) {
-            encode_symbol(cx, ebml_w, variant.id);
+        encode_type(ebml_w, trans.node_ann_type(cx, variant.node.ann));
+        if (_vec.len[ast.variant_arg](variant.node.args) > 0u) {
+            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);
     }
 }
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 1ceb7e66744..39c4294d6bc 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -389,7 +389,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns)
                     case (ast.mie_tag_variant(?item, ?variant_idx)) {
                         alt (item.node) {
                             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);
                                 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 {
         alt (item.node) {
             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);
                 ret def_wrap_other(t);
             }
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 9df068f3e4c..2471d85ed99 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -1355,7 +1355,7 @@ fn GEP_tag(@block_ctxt cx,
 
     // Synthesize a tuple type so that GEP_tup_like() can work its magic.
     // 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 i = 0;
     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] {
     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, _)) {
             for (ty.arg arg in args) {
                 tys += vec(arg.ty);
@@ -1931,7 +1931,7 @@ fn tag_variant_with_id(@crate_ctxt cx,
     auto i = 0u;
     while (i < _vec.len[ast.variant](variants)) {
         auto variant = variants.(i);
-        if (common.def_eq(variant.id, variant_id)) {
+        if (common.def_eq(variant.node.id, variant_id)) {
             ret variant;
         }
         i += 1u;
@@ -2074,9 +2074,9 @@ fn iter_structural_ty_full(@block_ctxt cx,
                                                      _uint.to_str(i, 10u));
                 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.
-                    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) {
                         case (ty.ty_fn(_, ?args, _)) {
                             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 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;
                                 variant_cx = rslt.bcx;
 
                                 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;
                                 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 i = 0;
             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 &&
                     variant_id._1 == this_variant_id._1) {
                     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) {
                             case (ast.item_tag(_, ?variants, _, _)) {
                                 for (ast.variant v in variants) {
-                                    if (v.id == vid) {
+                                    if (v.node.id == vid) {
                                         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,
                      &ast.variant variant, int index,
                      &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
     }
 
     // Translate variant arguments to function arguments.
     let vec[ast.arg] fn_args = vec();
     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,
                            ty=varg.ty,
                            ident="arg" + _uint.to_str(i, 10u),
                            id=varg.id));
     }
 
-    check (cx.item_ids.contains_key(variant.id));
-    let ValueRef llfndecl = cx.item_ids.get(variant.id);
+    check (cx.item_ids.contains_key(variant.node.id));
+    let ValueRef llfndecl = cx.item_ids.get(variant.node.id);
 
     auto fcx = new_fn_ctxt(cx, llfndecl);
 
     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);
 
     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)));
     }
 
-    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);
 
     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)));
 
     i = 0u;
-    for (ast.variant_arg va in variant.args) {
-        auto rslt = GEP_tag(bcx, llblobptr, tag_id, variant.id,
+    for (ast.variant_arg va in variant.node.args) {
+        auto rslt = GEP_tag(bcx, llblobptr, tag_id, variant.node.id,
                             ty_param_substs, i as int);
         bcx = rslt.bcx;
         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, _)) {
             for (ast.variant variant in variants) {
-                if (_vec.len[ast.variant_arg](variant.args) != 0u) {
-                    decl_fn_and_pair(extend_path(cx, variant.name), "tag",
-                                     tps, variant.ann, variant.id);
+                if (_vec.len[ast.variant_arg](variant.node.args) != 0u) {
+                    decl_fn_and_pair(extend_path(cx, variant.node.name),
+                                     "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
                                     as llvm.Linkage);
 
-                cx.discrims.insert(variant.id, discrim_gvar);
-                cx.discrim_symbols.insert(variant.id, s);
+                cx.discrims.insert(variant.node.id, discrim_gvar);
+                cx.discrim_symbols.insert(variant.node.id, s);
 
                 i += 1u;
             }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index ff13ad93013..9ea1c44c750 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -656,7 +656,7 @@ fn collect_item_types(session.session sess, @ast.crate crate)
             // Nullary tag constructors get turned into constants; n-ary tag
             // constructors get turned into functions.
             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));
             } else {
                 // 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, _);
 
                 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);
                     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);
-            type_cache.insert(variant.id, tpt);
+            type_cache.insert(variant.node.id, tpt);
 
             auto variant_t = rec(
                 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;
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index 258df73f719..0007cfd5f9e 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -4,6 +4,7 @@ import std.io;
 import std.option;
 import front.ast;
 import front.lexer;
+import util.common;
 import pp.end; import pp.wrd; import pp.space; import pp.line;
 
 const uint indent_unit = 4u;
@@ -59,11 +60,11 @@ impure fn bclose(ps s) {
     end(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);
     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;
     for (IN elt in elts) {
         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);
     }
 }
+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) {
     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_int) {wrd(s.s, "int");}
         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_str) {wrd(s.s, "str");}
         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);
                 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;
-            commasep[ast.ty_field](s, fields, f);
+            auto gs = get_span;
+            commasep_cmnt[ast.ty_field](s, fields, f, gs);
             pclose(s);
         }
         case (ast.ty_obj(?methods)) {
@@ -219,18 +247,19 @@ impure fn print_item(ps s, @ast.item item) {
             space(s.s);
             bopen(s);
             for (ast.variant v in variants) {
-                wrd(s.s, v.name);
-                if (_vec.len[ast.variant_arg](v.args) > 0u) {
+                maybe_print_comment(s, v.span.lo);
+                wrd(s.s, v.node.name);
+                if (_vec.len[ast.variant_arg](v.node.args) > 0u) {
                     popen(s);
                     impure fn print_variant_arg(ps s, &ast.variant_arg arg) {
                         print_type(s, arg.ty);
                     }
                     auto f = print_variant_arg;
-                    commasep[ast.variant_arg](s, v.args, f);
+                    commasep[ast.variant_arg](s, v.node.args, f);
                     pclose(s);
                 }
                 wrd(s.s, ";");
-                line(s.s);
+                if (!maybe_print_line_comment(s, v.span)) {line(s.s);}
             }
             bclose_c(s, item.span);
         }
@@ -246,8 +275,10 @@ impure fn print_item(ps s, @ast.item item) {
                 wrd(s.s, field.ident);
                 end(s.s);
             }
+            fn get_span(&ast.obj_field f) -> common.span {ret f.ty.span;}
             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);
             space(s.s);
             bopen(s);
@@ -284,25 +315,25 @@ impure fn print_block(ps s, ast.block blk) {
     maybe_print_comment(s, blk.span.lo);
     bopen(s);
     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);
         }
-        cur_line = blk.span.hi.line;
+        cur_line = st.span.hi.line;
         maybe_print_comment(s, st.span.lo);
         alt (st.node) {
             case (ast.stmt_decl(?decl)) {print_decl(s, decl);}
             case (ast.stmt_expr(?expr)) {print_expr(s, expr);}
         }
         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) {
         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);
             }
             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 (_) {}
     }
@@ -318,17 +349,17 @@ impure fn print_literal(ps s, @ast.lit lit) {
                 + "'");
         }
         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?
-            wrd(s.s, util.common.istr(val as int) + "u");
+            wrd(s.s, common.istr(val as int) + "u");
         }
         case (ast.lit_float(?fstr)) {
             wrd(s.s, fstr);
         }
         case (ast.lit_mach_int(?mach,?val)) {
-            wrd(s.s, util.common.istr(val as int));
-            wrd(s.s, util.common.ty_mach_to_str(mach));
+            wrd(s.s, common.istr(val as int));
+            wrd(s.s, common.ty_mach_to_str(mach));
         }
         case (ast.lit_nil) {wrd(s.s, "()");}
         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) {
     maybe_print_comment(s, expr.span.lo);
-    auto pe = print_expr;
     hbox(s);
     alt (expr.node) {
         case (ast.expr_vec(?exprs,?mut,_)) {
@@ -348,7 +378,7 @@ impure fn print_expr(ps s, &@ast.expr expr) {
             }
             wrd(s.s, "vec");
             popen(s);
-            commasep[@ast.expr](s, exprs, pe);
+            commasep_exprs(s, exprs);
             pclose(s);
         }
         case (ast.expr_tup(?exprs,_)) {
@@ -358,10 +388,12 @@ impure fn print_expr(ps s, &@ast.expr expr) {
                 print_expr(s, elt.expr);
                 end(s.s);
             }
+            fn get_span(&ast.elt elt) -> common.span {ret elt.expr.span;}
             wrd(s.s, "tup");
             popen(s);
             auto f = printElt;
-            commasep[ast.elt](s, exprs, f);
+            auto gs = get_span;
+            commasep_cmnt[ast.elt](s, exprs, f, gs);
             pclose(s);
         }
         case (ast.expr_rec(?fields,?wth,_)) {
@@ -373,10 +405,14 @@ impure fn print_expr(ps s, &@ast.expr expr) {
                 print_expr(s, field.expr);
                 end(s.s);
             }
+            fn get_span(&ast.field field) -> common.span {
+                ret field.expr.span;
+            }
             wrd(s.s, "rec");
             popen(s);
             auto f = print_field;
-            commasep[ast.field](s, fields, f);
+            auto gs = get_span;
+            commasep_cmnt[ast.field](s, fields, f, gs);
             alt (wth) {
                 case (option.some[@ast.expr](?expr)) {
                     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,_)) {
             print_expr(s, func);
             popen(s);
-            commasep[@ast.expr](s, args, pe);
+            commasep_exprs(s, args);
             pclose(s);
         }
         case (ast.expr_bind(?func,?args,_)) {
@@ -598,7 +634,7 @@ impure fn print_expr(ps s, &@ast.expr expr) {
             print_path(s, path);
             if (_vec.len[@ast.expr](args) > 0u) {
                 popen(s);
-                commasep[@ast.expr](s, args, pe);
+                commasep_exprs(s, args);
                 pclose(s);
             }
             // 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) {
         alt (next_comment(s)) {
             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)) {
         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, " ");
                 print_comment(s, cmnt.val);
                 s.cur_cmnt += 1u;