rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Graydon Hoare
2011-05-30 15:56:01 -07:00
parent d12ea39896
commit b48cab962a
8 changed files with 27 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/comp/front/ast.rs
View File

@@ -229,7 +229,8 @@ tag decl_ {
type arm = rec(@pat pat, block block); type arm = rec(@pat pat, block block);
type elt = rec(mutability mut, @expr expr); 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 { tag spawn_dom {
dom_implicit; dom_implicit;

4
src/comp/front/extfmt.rs
View File

@@ -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) { for (tup(ast::ident, @ast::expr) field in fields) {
auto ident = field._0; auto ident = field._0;
auto val = field._1; auto val = field._1;
auto astfield = rec(mut = ast::imm, auto astfield = rec(node=rec(mut = ast::imm,
ident = ident, ident = ident,
expr = val); expr = val), span=sp);
astfields += [astfield]; astfields += [astfield];
} }

3
src/comp/front/parser.rs
View File

@@ -737,11 +737,12 @@ fn parse_mutability(&parser p) -> ast::mutability {
} }
fn parse_field(&parser p) -> ast::field { fn parse_field(&parser p) -> ast::field {
auto lo = p.get_lo_pos();
auto m = parse_mutability(p); auto m = parse_mutability(p);
auto i = parse_ident(p); auto i = parse_ident(p);
expect(p, token::EQ); expect(p, token::EQ);
auto e = parse_expr(p); 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 { fn parse_bottom_expr(&parser p) -> @ast::expr {

4
src/comp/middle/trans.rs
View File

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

17
src/comp/middle/typeck.rs
View File

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

2
src/comp/middle/walk.rs
View File

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

12
src/comp/pretty/pprust.rs
View File

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

2
src/comp/util/common.rs
View File

@@ -118,7 +118,7 @@ fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] {
ret vec::map[ast::elt, @ast::expr](f, elts); 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] { fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] {
auto f = field_expr; auto f = field_expr;