Add span to field to catch per-field comments in rec exprs.

Author: graydon

src/comp/front/ast.rs

@@ -229,7 +229,8 @@ tag decl_ {
 type arm = rec(@pat pat, block block);
 
 type elt = rec(mutability mut, @expr expr);
-type field = rec(mutability mut, ident ident, @expr expr);
+type field_ = rec(mutability mut, ident ident, @expr expr);
+type field = spanned[field_];
 
 tag spawn_dom {
     dom_implicit;

src/comp/front/extfmt.rs

@@ -148,9 +148,9 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
         for (tup(ast::ident, @ast::expr) field in fields) {
             auto ident = field._0;
             auto val = field._1;
-            auto astfield = rec(mut = ast::imm,
-                                ident = ident,
-                                expr = val);
+            auto astfield = rec(node=rec(mut = ast::imm,
+                                         ident = ident,
+                                         expr = val), span=sp);
             astfields += [astfield];
         }
 

src/comp/front/parser.rs

@@ -737,11 +737,12 @@ fn parse_mutability(&parser p) -> ast::mutability {
 }
 
 fn parse_field(&parser p) -> ast::field {
+    auto lo = p.get_lo_pos();
     auto m = parse_mutability(p);
     auto i = parse_ident(p);
     expect(p, token::EQ);
     auto e = parse_expr(p);
-    ret rec(mut=m, ident=i, expr=e);
+    ret spanned(lo, e.span.hi, rec(mut=m, ident=i, expr=e));
 }
 
 fn parse_bottom_expr(&parser p) -> @ast::expr {

src/comp/middle/trans.rs

@@ -5423,9 +5423,9 @@ fn trans_rec(&@block_ctxt cx, &vec[ast::field] fields,
         auto src_res = res(bcx, C_nil());
 
         for (ast::field f in fields) {
-            if (str::eq(f.ident, tf.ident)) {
+            if (str::eq(f.node.ident, tf.ident)) {
                 expr_provided = true;
-                src_res = trans_expr(bcx, f.expr);
+                src_res = trans_expr(bcx, f.node.expr);
             }
         }
         if (!expr_provided) {

src/comp/middle/typeck.rs

@@ -1248,11 +1248,11 @@ mod pushdown {
                             case (none) {
                                 auto i = 0u;
                                 for (ast::field field_0 in fields_0) {
-                                    assert (str::eq(field_0.ident,
+                                    assert (str::eq(field_0.node.ident,
                                                     field_mts.(i).ident));
                                     pushdown_expr(scx,
                                                   field_mts.(i).mt.ty,
-                                                  field_0.expr);
+                                                  field_0.node.expr);
                                     i += 1u;
                                 }
                             }
@@ -1263,10 +1263,10 @@ mod pushdown {
                                 for (ast::field field_0 in fields_0) {
 
                                     for (ty::field ft in field_mts) {
-                                        if (str::eq(field_0.ident,
+                                        if (str::eq(field_0.node.ident,
                                                     ft.ident)) {
                                             pushdown_expr(scx, ft.mt.ty,
-                                                          field_0.expr);
+                                                          field_0.node.expr);
                                         }
                                     }
                                 }
@@ -2461,11 +2461,12 @@ fn check_expr(&@stmt_ctxt scx, &@ast::expr expr) {
             let vec[field] fields_t = [];
 
             for (ast::field f in fields) {
-                check_expr(scx, f.expr);
-                auto expr_t = expr_ty(scx.fcx.ccx.tcx, f.expr);
+                check_expr(scx, f.node.expr);
+                auto expr_t = expr_ty(scx.fcx.ccx.tcx, f.node.expr);
 
-                auto expr_mt = rec(ty=expr_t, mut=f.mut);
-                vec::push[field](fields_t, rec(ident=f.ident, mt=expr_mt));
+                auto expr_mt = rec(ty=expr_t, mut=f.node.mut);
+                vec::push[field](fields_t, rec(ident=f.node.ident,
+                                               mt=expr_mt));
             }
 
             alt (base) {

src/comp/middle/walk.rs

@@ -323,7 +323,7 @@ fn walk_expr(&ast_visitor v, @ast::expr e) {
         }
         case (ast::expr_rec(?flds, ?base, _)) {
             for (ast::field f in flds) {
-                walk_expr(v, f.expr);
+                walk_expr(v, f.node.expr);
             }
             walk_expr_opt(v, base);
         }

src/comp/pretty/pprust.rs

@@ -140,6 +140,7 @@ fn commasep_cmnt[IN](ps s, breaks b, vec[IN] elts, fn(ps, &IN) op,
     auto len = vec::len[IN](elts);
     auto i = 0u;
     for (IN elt in elts) {
+        maybe_print_comment(s, get_span(elt).hi);
         op(s, elt);
         i += 1u;
         if (i < len) {
@@ -485,14 +486,14 @@ fn print_expr(ps s, &@ast::expr expr) {
         case (ast::expr_rec(?fields,?wth,_)) {
             fn print_field(ps s, &ast::field field) {
                 ibox(s.s, indent_unit);
-                if (field.mut == ast::mut) {word_nbsp(s, "mutable");}
-                word(s.s, field.ident);
+                if (field.node.mut == ast::mut) {word_nbsp(s, "mutable");}
+                word(s.s, field.node.ident);
                 word(s.s, "=");
-                print_expr(s, field.expr);
+                print_expr(s, field.node.expr);
                 end(s.s);
             }
             fn get_span(&ast::field field) -> common::span {
-                ret field.expr.span;
+                ret field.span;
             }
             word(s.s, "rec");
             popen(s);
@@ -1132,8 +1133,8 @@ fn print_comment(ps s, lexer::cmnt cmnt) {
                 zerobreak(s.s);
                 word_and_eol(s.s, line);
             }
-            zerobreak(s.s);
             end(s.s);
+            zerobreak(s.s);
         }
         case (lexer::trailing) {
             cbox(s.s, 0u);
@@ -1142,6 +1143,7 @@ fn print_comment(ps s, lexer::cmnt cmnt) {
                 zerobreak(s.s);
             }
             end(s.s);
+            zerobreak(s.s);
         }
         case (lexer::mixed) {
             assert vec::len(cmnt.lines) == 1u;

src/comp/util/common.rs

@@ -118,7 +118,7 @@ fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] {
     ret vec::map[ast::elt, @ast::expr](f, elts);
 }
 
-fn field_expr(&ast::field f) -> @ast::expr { ret f.expr; }
+fn field_expr(&ast::field f) -> @ast::expr { ret f.node.expr; }
 
 fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] {
     auto f = field_expr;