Skip to content

Commit 629b920

Browse files
graydongraydon
committed
---
yaml --- r: 982 b: refs/heads/master c: 4504337 h: refs/heads/master v: v3
1 parent 6896345 commit 629b920

File tree

6 files changed

+118
-118
lines changed

6 files changed

+118
-118
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,2 @@
11
---
2-
refs/heads/master: 567a45cc70424b77cac489940a36ff8a6ea97b84
2+
refs/heads/master: 45043374ff4d4eb48bed52ff8f8251f9cddf239a

‎trunk/src/comp/front/ast.rs

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -109,11 +109,14 @@ tag decl_ {
109109

110110
type arm = rec(@pat pat, block block);
111111

112+
type elt = rec(mutability mut, @expr expr);
113+
type field = rec(mutability mut, ident ident, @expr expr);
114+
112115
type expr = spanned[expr_];
113116
tag expr_ {
114117
expr_vec(vec[@expr], ann);
115-
expr_tup(vec[tup(mutability, @expr)], ann);
116-
expr_rec(vec[tup(ident,@expr)], ann);
118+
expr_tup(vec[elt], ann);
119+
expr_rec(vec[field], ann);
117120
expr_call(@expr, vec[@expr], ann);
118121
expr_binary(binop, @expr, @expr, ann);
119122
expr_unary(unop, @expr, ann);
@@ -143,6 +146,7 @@ tag lit_ {
143146

144147
// NB: If you change this, you'll probably want to change the corresponding
145148
// type structure in middle/typeck.rs as well.
149+
type ty_field = rec(ident ident, @ty ty);
146150
type ty = spanned[ty_];
147151
tag ty_ {
148152
ty_nil;
@@ -155,7 +159,7 @@ tag ty_ {
155159
ty_box(@ty);
156160
ty_vec(@ty);
157161
ty_tup(vec[@ty]);
158-
ty_rec(vec[tup(ident,@ty)]);
162+
ty_rec(vec[ty_field]);
159163
ty_fn(vec[rec(mode mode, @ty ty)], @ty); // TODO: effect
160164
ty_path(path, option.t[def]);
161165
ty_mutable(@ty);

‎trunk/src/comp/front/parser.rs

Lines changed: 30 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -189,17 +189,17 @@ impure fn parse_ty(parser p) -> @ast.ty {
189189

190190
case (token.REC) {
191191
p.bump();
192-
impure fn parse_field(parser p) -> tup(ast.ident, @ast.ty) {
192+
impure fn parse_field(parser p) -> ast.ty_field {
193193
auto ty = parse_ty(p);
194194
auto id = parse_ident(p);
195-
ret tup(id,ty);
195+
ret rec(ident=id, ty=ty);
196196
}
197197
auto f = parse_field; // FIXME: trans_const_lval bug
198198
auto elems =
199-
parse_seq[tup(ast.ident, @ast.ty)](token.LPAREN,
200-
token.RPAREN,
201-
some(token.COMMA),
202-
f, p);
199+
parse_seq[ast.ty_field](token.LPAREN,
200+
token.RPAREN,
201+
some(token.COMMA),
202+
f, p);
203203
hi = p.get_span();
204204
t = ast.ty_rec(elems.node);
205205
}
@@ -352,17 +352,12 @@ impure fn parse_name(parser p, ast.ident id) -> ast.name {
352352
ret spanned(lo, tys.span, rec(ident=id, types=tys.node));
353353
}
354354

355-
impure fn parse_possibly_mutable_expr(parser p)
356-
-> tup(ast.mutability, @ast.expr) {
357-
auto mut;
355+
impure fn parse_mutabliity(parser p) -> ast.mutability {
358356
if (p.peek() == token.MUTABLE) {
359357
p.bump();
360-
mut = ast.mut;
361-
} else {
362-
mut = ast.imm;
358+
ret ast.mut;
363359
}
364-
365-
ret tup(mut, parse_expr(p));
360+
ret ast.imm;
366361
}
367362

368363
impure fn parse_bottom_expr(parser p) -> @ast.expr {
@@ -415,13 +410,17 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
415410

416411
case (token.TUP) {
417412
p.bump();
418-
auto pf = parse_possibly_mutable_expr;
413+
impure fn parse_elt(parser p) -> ast.elt {
414+
auto m = parse_mutabliity(p);
415+
auto e = parse_expr(p);
416+
ret rec(mut=m, expr=e);
417+
}
418+
auto pf = parse_elt;
419419
auto es =
420-
parse_seq[tup(ast.mutability, @ast.expr)]
421-
(token.LPAREN,
422-
token.RPAREN,
423-
some(token.COMMA),
424-
pf, p);
420+
parse_seq[ast.elt](token.LPAREN,
421+
token.RPAREN,
422+
some(token.COMMA),
423+
pf, p);
425424
hi = es.span;
426425
ex = ast.expr_tup(es.node, ast.ann_none);
427426
}
@@ -439,21 +438,21 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
439438

440439
case (token.REC) {
441440
p.bump();
442-
impure fn parse_entry(parser p) ->
443-
tup(ast.ident, @ast.expr) {
441+
impure fn parse_field(parser p) -> ast.field {
442+
auto m = parse_mutabliity(p);
444443
auto i = parse_ident(p);
445444
expect(p, token.EQ);
446445
auto e = parse_expr(p);
447-
ret tup(i, e);
446+
ret rec(mut=m, ident=i, expr=e);
448447
}
449-
auto pf = parse_entry;
450-
auto es =
451-
parse_seq[tup(ast.ident, @ast.expr)](token.LPAREN,
452-
token.RPAREN,
453-
some(token.COMMA),
454-
pf, p);
455-
hi = es.span;
456-
ex = ast.expr_rec(es.node, ast.ann_none);
448+
auto pf = parse_field;
449+
auto fs =
450+
parse_seq[ast.field](token.LPAREN,
451+
token.RPAREN,
452+
some(token.COMMA),
453+
pf, p);
454+
hi = fs.span;
455+
ex = ast.expr_rec(fs.node, ast.ann_none);
457456
}
458457

459458
case (_) {

‎trunk/src/comp/middle/fold.rs

Lines changed: 27 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ type ast_fold[ENV] =
4949
(fn(&ENV e, &span sp, vec[@ty] elts) -> @ty) fold_ty_tup,
5050

5151
(fn(&ENV e, &span sp,
52-
vec[tup(ident,@ty)] elts) -> @ty) fold_ty_rec,
52+
vec[ast.ty_field] elts) -> @ty) fold_ty_rec,
5353

5454
(fn(&ENV e, &span sp,
5555
vec[rec(ast.mode mode, @ty ty)] inputs,
@@ -65,12 +65,10 @@ type ast_fold[ENV] =
6565
vec[@expr] es, ann a) -> @expr) fold_expr_vec,
6666

6767
(fn(&ENV e, &span sp,
68-
vec[tup(mutability,@expr)] es,
69-
ann a) -> @expr) fold_expr_tup,
68+
vec[ast.elt] es, ann a) -> @expr) fold_expr_tup,
7069

7170
(fn(&ENV e, &span sp,
72-
vec[tup(ident,@expr)] fields,
73-
ann a) -> @expr) fold_expr_rec,
71+
vec[ast.field] fields, ann a) -> @expr) fold_expr_rec,
7472

7573
(fn(&ENV e, &span sp,
7674
@expr f, vec[@expr] args,
@@ -252,16 +250,16 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
252250
for (@ty elt in elts) {
253251
append[@ty](elts_,fold_ty(env, fld, elt));
254252
}
255-
ret fld.fold_ty_tup(env_, t.span, elts);
253+
ret fld.fold_ty_tup(env_, t.span, elts_);
256254
}
257255

258-
case (ast.ty_rec(?elts)) {
259-
let vec[tup(ident,@ty)] elts_ = vec();
260-
for (tup(ident, @ty) elt in elts) {
261-
append[tup(ident, @ty)]
262-
(elts_, tup(elt._0, fold_ty(env, fld, elt._1)));
256+
case (ast.ty_rec(?flds)) {
257+
let vec[ast.ty_field] flds_ = vec();
258+
for (ast.ty_field f in flds) {
259+
append[ast.ty_field]
260+
(flds_, rec(ty=fold_ty(env, fld, f.ty) with f));
263261
}
264-
ret fld.fold_ty_rec(env_, t.span, elts);
262+
ret fld.fold_ty_rec(env_, t.span, flds_);
265263
}
266264

267265
case (ast.ty_path(?pth, ?ref_opt)) {
@@ -347,14 +345,13 @@ fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] {
347345
ret exprs;
348346
}
349347

350-
fn fold_tup_entry[ENV](&ENV env, ast_fold[ENV] fld,
351-
&tup(mutability,@expr) e) -> tup(mutability,@expr) {
352-
ret tup(e._0, fold_expr(env, fld, e._1));
348+
fn fold_tup_elt[ENV](&ENV env, ast_fold[ENV] fld, &ast.elt e) -> ast.elt {
349+
ret rec(expr=fold_expr(env, fld, e.expr) with e);
353350
}
354351

355-
fn fold_rec_entry[ENV](&ENV env, ast_fold[ENV] fld, &tup(ident,@expr) e)
356-
-> tup(ident,@expr) {
357-
ret tup(e._0, fold_expr(env, fld, e._1));
352+
fn fold_rec_field[ENV](&ENV env, ast_fold[ENV] fld, &ast.field f)
353+
-> ast.field {
354+
ret rec(expr=fold_expr(env, fld, f.expr) with f);
358355
}
359356

360357
fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
@@ -372,19 +369,19 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
372369
}
373370

374371
case (ast.expr_tup(?es, ?t)) {
375-
let vec[tup(mutability,@expr)] entries = vec();
376-
for (tup(mutability,@expr) entry in es) {
377-
entries += fold_tup_entry[ENV](env, fld, entry);
372+
let vec[ast.elt] elts = vec();
373+
for (ast.elt e in es) {
374+
elts += fold_tup_elt[ENV](env, fld, e);
378375
}
379-
ret fld.fold_expr_tup(env_, e.span, entries, t);
376+
ret fld.fold_expr_tup(env_, e.span, elts, t);
380377
}
381378

382-
case (ast.expr_rec(?es, ?t)) {
383-
let vec[tup(ident,@expr)] entries = vec();
384-
for (tup(ident,@expr) entry in es) {
385-
entries += fold_rec_entry(env, fld, entry);
379+
case (ast.expr_rec(?fs, ?t)) {
380+
let vec[ast.field] fields = vec();
381+
for (ast.field f in fs) {
382+
fields += fold_rec_field(env, fld, f);
386383
}
387-
ret fld.fold_expr_rec(env_, e.span, entries, t);
384+
ret fld.fold_expr_rec(env_, e.span, fields, t);
388385
}
389386

390387
case (ast.expr_call(?f, ?args, ?t)) {
@@ -680,7 +677,7 @@ fn identity_fold_ty_tup[ENV](&ENV env, &span sp,
680677
}
681678

682679
fn identity_fold_ty_rec[ENV](&ENV env, &span sp,
683-
vec[tup(ident,@ty)] elts) -> @ty {
680+
vec[ast.ty_field] elts) -> @ty {
684681
ret @respan(sp, ast.ty_rec(elts));
685682
}
686683

@@ -708,13 +705,12 @@ fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es,
708705
}
709706

710707
fn identity_fold_expr_tup[ENV](&ENV env, &span sp,
711-
vec[tup(mutability, @expr)] es,
712-
ann a) -> @expr {
708+
vec[ast.elt] es, ann a) -> @expr {
713709
ret @respan(sp, ast.expr_tup(es, a));
714710
}
715711

716712
fn identity_fold_expr_rec[ENV](&ENV env, &span sp,
717-
vec[tup(ident,@expr)] fields, ann a) -> @expr {
713+
vec[ast.field] fields, ann a) -> @expr {
718714
ret @respan(sp, ast.expr_rec(fields, a));
719715
}
720716

‎trunk/src/comp/middle/trans.rs

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1197,15 +1197,15 @@ impure fn trans_call(@block_ctxt cx, @ast.expr f,
11971197
args_res._0.build.FastCall(f_res._0.val, args_res._1));
11981198
}
11991199

1200-
impure fn trans_tup(@block_ctxt cx, vec[tup(ast.mutability, @ast.expr)] args,
1200+
impure fn trans_tup(@block_ctxt cx, vec[ast.elt] elts,
12011201
&ast.ann ann) -> result {
12021202
auto ty = node_type(cx.fcx.ccx, ann);
12031203
auto tup_val = cx.build.Alloca(ty);
12041204
let int i = 0;
12051205
auto r = res(cx, C_nil());
1206-
for (tup(ast.mutability, @ast.expr) arg in args) {
1207-
auto t = typeck.expr_ty(arg._1);
1208-
auto src_res = trans_expr(r.bcx, arg._1);
1206+
for (ast.elt e in elts) {
1207+
auto t = typeck.expr_ty(e.expr);
1208+
auto src_res = trans_expr(r.bcx, e.expr);
12091209
auto dst_elt = r.bcx.build.GEP(tup_val, vec(C_int(0), C_int(i)));
12101210
// FIXME: calculate copy init-ness in typestate.
12111211
r = copy_ty(src_res.bcx, true, dst_elt, src_res.val, t);
@@ -1214,21 +1214,21 @@ impure fn trans_tup(@block_ctxt cx, vec[tup(ast.mutability, @ast.expr)] args,
12141214
ret res(r.bcx, tup_val);
12151215
}
12161216

1217-
impure fn trans_rec(@block_ctxt cx, vec[tup(ast.ident, @ast.expr)] args,
1217+
impure fn trans_rec(@block_ctxt cx, vec[ast.field] fields,
12181218
&ast.ann ann) -> result {
12191219
auto ty = node_type(cx.fcx.ccx, ann);
1220-
auto tup_val = cx.build.Alloca(ty);
1220+
auto rec_val = cx.build.Alloca(ty);
12211221
let int i = 0;
12221222
auto r = res(cx, C_nil());
1223-
for (tup(ast.ident, @ast.expr) arg in args) {
1224-
auto t = typeck.expr_ty(arg._1);
1225-
auto src_res = trans_expr(r.bcx, arg._1);
1226-
auto dst_elt = r.bcx.build.GEP(tup_val, vec(C_int(0), C_int(i)));
1223+
for (ast.field f in fields) {
1224+
auto t = typeck.expr_ty(f.expr);
1225+
auto src_res = trans_expr(r.bcx, f.expr);
1226+
auto dst_elt = r.bcx.build.GEP(rec_val, vec(C_int(0), C_int(i)));
12271227
// FIXME: calculate copy init-ness in typestate.
12281228
r = copy_ty(src_res.bcx, true, dst_elt, src_res.val, t);
12291229
i += 1;
12301230
}
1231-
ret res(r.bcx, tup_val);
1231+
ret res(r.bcx, rec_val);
12321232
}
12331233

12341234

0 commit comments

Comments
 (0)