Skip to content

Commit bb1ce5f

Browse files
graydongraydon
committed
---
yaml --- r: 973 b: refs/heads/master c: 386f363 h: refs/heads/master i: 971: ae4b87d v: v3
1 parent fddb182 commit bb1ce5f

File tree

6 files changed

+66
-50
lines changed

6 files changed

+66
-50
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: 38846e39c4be0f12241ab0df2e94cbb366ae34ba
2+
refs/heads/master: 386f363cfea72899fa3c3f2a194d00819cdbe806

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

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,11 @@ tag pat_ {
4848
pat_tag(ident, vec[@pat], ann);
4949
}
5050

51+
tag mutability {
52+
mut;
53+
imm;
54+
}
55+
5156
tag binop {
5257
add;
5358
sub;
@@ -105,7 +110,7 @@ type arm = rec(@pat pat, block block);
105110
type expr = spanned[expr_];
106111
tag expr_ {
107112
expr_vec(vec[@expr], ann);
108-
expr_tup(vec[tup(bool /* mutability */, @expr)], ann);
113+
expr_tup(vec[tup(mutability, @expr)], ann);
109114
expr_rec(vec[tup(ident,@expr)], ann);
110115
expr_call(@expr, vec[@expr], ann);
111116
expr_binary(binop, @expr, @expr, ann);
@@ -147,7 +152,7 @@ tag ty_ {
147152
ty_str;
148153
ty_box(@ty);
149154
ty_vec(@ty);
150-
ty_tup(vec[tup(bool /* mutability */, @ty)]);
155+
ty_tup(vec[tup(mutability, @ty)]);
151156
ty_fn(vec[rec(mode mode, @ty ty)], @ty); // TODO: effect
152157
ty_path(path, option.t[def]);
153158
ty_mutable(@ty);

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

Lines changed: 18 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -96,13 +96,14 @@ impure fn parse_ident(parser p) -> ast.ident {
9696
}
9797
}
9898

99-
impure fn parse_possibly_mutable_ty(parser p) -> tup(bool, @ast.ty) {
99+
impure fn parse_possibly_mutable_ty(parser p)
100+
-> tup(ast.mutability, @ast.ty) {
100101
auto mut;
101102
if (p.peek() == token.MUTABLE) {
102103
p.bump();
103-
mut = true;
104+
mut = ast.mut;
104105
} else {
105-
mut = false;
106+
mut = ast.imm;
106107
}
107108

108109
ret tup(mut, parse_ty(p));
@@ -192,8 +193,10 @@ impure fn parse_ty(parser p) -> @ast.ty {
192193
case (token.TUP) {
193194
p.bump();
194195
auto f = parse_possibly_mutable_ty; // FIXME: trans_const_lval bug
195-
auto elems = parse_seq[tup(bool, @ast.ty)](token.LPAREN,
196-
token.RPAREN, some(token.COMMA), f, p);
196+
auto elems =
197+
parse_seq[tup(ast.mutability, @ast.ty)]
198+
(token.LPAREN,
199+
token.RPAREN, some(token.COMMA), f, p);
197200
hi = p.get_span();
198201
t = ast.ty_tup(elems.node);
199202
}
@@ -346,13 +349,14 @@ impure fn parse_name(parser p, ast.ident id) -> ast.name {
346349
ret spanned(lo, tys.span, rec(ident=id, types=tys.node));
347350
}
348351

349-
impure fn parse_possibly_mutable_expr(parser p) -> tup(bool, @ast.expr) {
352+
impure fn parse_possibly_mutable_expr(parser p)
353+
-> tup(ast.mutability, @ast.expr) {
350354
auto mut;
351355
if (p.peek() == token.MUTABLE) {
352356
p.bump();
353-
mut = true;
357+
mut = ast.mut;
354358
} else {
355-
mut = false;
359+
mut = ast.imm;
356360
}
357361

358362
ret tup(mut, parse_expr(p));
@@ -409,10 +413,12 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
409413
case (token.TUP) {
410414
p.bump();
411415
auto pf = parse_possibly_mutable_expr;
412-
auto es = parse_seq[tup(bool, @ast.expr)](token.LPAREN,
413-
token.RPAREN,
414-
some(token.COMMA),
415-
pf, p);
416+
auto es =
417+
parse_seq[tup(ast.mutability, @ast.expr)]
418+
(token.LPAREN,
419+
token.RPAREN,
420+
some(token.COMMA),
421+
pf, p);
416422
hi = es.span;
417423
ex = ast.expr_tup(es.node, ast.ann_none);
418424
}

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

Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import front.ast;
1313
import front.ast.ident;
1414
import front.ast.name;
1515
import front.ast.path;
16+
import front.ast.mutability;
1617
import front.ast.ty;
1718
import front.ast.expr;
1819
import front.ast.stmt;
@@ -46,7 +47,7 @@ type ast_fold[ENV] =
4647
(fn(&ENV e, &span sp, @ty t) -> @ty) fold_ty_vec,
4748

4849
(fn(&ENV e, &span sp,
49-
vec[tup(bool, @ty)] elts) -> @ty) fold_ty_tup,
50+
vec[tup(mutability, @ty)] elts) -> @ty) fold_ty_tup,
5051

5152
(fn(&ENV e, &span sp,
5253
vec[rec(ast.mode mode, @ty ty)] inputs,
@@ -62,7 +63,7 @@ type ast_fold[ENV] =
6263
vec[@expr] es, ann a) -> @expr) fold_expr_vec,
6364

6465
(fn(&ENV e, &span sp,
65-
vec[tup(bool,@expr)] es,
66+
vec[tup(mutability,@expr)] es,
6667
ann a) -> @expr) fold_expr_tup,
6768

6869
(fn(&ENV e, &span sp,
@@ -245,8 +246,8 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
245246
}
246247

247248
case (ast.ty_tup(?elts)) {
248-
let vec[tup(bool, @ty)] elts_ = vec();
249-
for (tup(bool, @ty) elt in elts) {
249+
let vec[tup(mutability, @ty)] elts_ = vec();
250+
for (tup(mutability, @ty) elt in elts) {
250251
elts_ += tup(elt._0, fold_ty(env, fld, elt._1));
251252
}
252253
ret fld.fold_ty_tup(env_, t.span, elts);
@@ -335,8 +336,8 @@ fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] {
335336
ret exprs;
336337
}
337338

338-
fn fold_tup_entry[ENV](&ENV env, ast_fold[ENV] fld, &tup(bool,@expr) e)
339-
-> tup(bool,@expr) {
339+
fn fold_tup_entry[ENV](&ENV env, ast_fold[ENV] fld,
340+
&tup(mutability,@expr) e) -> tup(mutability,@expr) {
340341
ret tup(e._0, fold_expr(env, fld, e._1));
341342
}
342343

@@ -360,8 +361,8 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
360361
}
361362

362363
case (ast.expr_tup(?es, ?t)) {
363-
let vec[tup(bool,@expr)] entries = vec();
364-
for (tup(bool,@expr) entry in es) {
364+
let vec[tup(mutability,@expr)] entries = vec();
365+
for (tup(mutability,@expr) entry in es) {
365366
entries += fold_tup_entry[ENV](env, fld, entry);
366367
}
367368
ret fld.fold_expr_tup(env_, e.span, entries, t);
@@ -650,8 +651,8 @@ fn identity_fold_ty_vec[ENV](&ENV env, &span sp, @ty t) -> @ty {
650651
ret @respan(sp, ast.ty_vec(t));
651652
}
652653

653-
fn identity_fold_ty_tup[ENV](&ENV env, &span sp, vec[tup(bool,@ty)] elts)
654-
-> @ty {
654+
fn identity_fold_ty_tup[ENV](&ENV env, &span sp,
655+
vec[tup(mutability,@ty)] elts) -> @ty {
655656
ret @respan(sp, ast.ty_tup(elts));
656657
}
657658

@@ -678,7 +679,8 @@ fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es,
678679
ret @respan(sp, ast.expr_vec(es, a));
679680
}
680681

681-
fn identity_fold_expr_tup[ENV](&ENV env, &span sp, vec[tup(bool, @expr)] es,
682+
fn identity_fold_expr_tup[ENV](&ENV env, &span sp,
683+
vec[tup(mutability, @expr)] es,
682684
ann a) -> @expr {
683685
ret @respan(sp, ast.expr_tup(es, a));
684686
}

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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -275,7 +275,7 @@ fn type_of_inner(@crate_ctxt cx, @typeck.ty t) -> TypeRef {
275275
}
276276
case (typeck.ty_tup(?elts)) {
277277
let vec[TypeRef] tys = vec();
278-
for (tup(bool, @typeck.ty) elt in elts) {
278+
for (tup(ast.mutability, @typeck.ty) elt in elts) {
279279
tys += type_of(cx, elt._1);
280280
}
281281
ret T_struct(tys);
@@ -493,7 +493,7 @@ fn iter_structural_ty(@block_ctxt cx,
493493
alt (t.struct) {
494494
case (typeck.ty_tup(?args)) {
495495
let int i = 0;
496-
for (tup(bool, @typeck.ty) arg in args) {
496+
for (tup(ast.mutability, @typeck.ty) arg in args) {
497497
auto elt = r.bcx.build.GEP(v, vec(C_int(0), C_int(i)));
498498
r = f(r.bcx, elt, arg._1);
499499
i += 1;
@@ -1184,13 +1184,13 @@ impure fn trans_call(@block_ctxt cx, @ast.expr f,
11841184
args_res._0.build.FastCall(f_res._0.val, args_res._1));
11851185
}
11861186

1187-
impure fn trans_tup(@block_ctxt cx, vec[tup(bool, @ast.expr)] args,
1187+
impure fn trans_tup(@block_ctxt cx, vec[tup(ast.mutability, @ast.expr)] args,
11881188
&ast.ann ann) -> result {
11891189
auto ty = node_type(cx.fcx.ccx, ann);
11901190
auto tup_val = cx.build.Alloca(ty);
11911191
let int i = 0;
11921192
auto r = res(cx, C_nil());
1193-
for (tup(bool, @ast.expr) arg in args) {
1193+
for (tup(ast.mutability, @ast.expr) arg in args) {
11941194
auto t = typeck.expr_ty(arg._1);
11951195
auto src_res = trans_expr(r.bcx, arg._1);
11961196
auto dst_elt = r.bcx.build.GEP(tup_val, vec(C_int(0), C_int(i)));

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

Lines changed: 23 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
import front.ast;
22
import front.ast.ann;
3+
import front.ast.mutability;
34
import middle.fold;
45
import driver.session;
56
import util.common;
@@ -28,7 +29,7 @@ type arg = rec(ast.mode mode, @ty ty);
2829

2930
// NB: If you change this, you'll probably want to change the corresponding
3031
// AST structure in front/ast.rs as well.
31-
type ty = rec(sty struct, bool mut, option.t[str] cname);
32+
type ty = rec(sty struct, mutability mut, option.t[str] cname);
3233
tag sty {
3334
ty_nil;
3435
ty_bool;
@@ -39,7 +40,7 @@ tag sty {
3940
ty_str;
4041
ty_box(@ty);
4142
ty_vec(@ty);
42-
ty_tup(vec[tup(bool /* mutability */, @ty)]);
43+
ty_tup(vec[tup(mutability, @ty)]);
4344
ty_fn(vec[arg], @ty); // TODO: effect
4445
ty_var(int); // ephemeral type var
4546
ty_local(ast.def_id); // type of a local var
@@ -65,9 +66,9 @@ type ty_getter = fn(ast.def_id) -> @ty;
6566
// Error-reporting utility functions
6667

6768
fn ast_ty_to_str(&@ast.ty ty) -> str {
68-
fn ast_tup_elem_to_str(&tup(bool, @ast.ty) elem) -> str {
69+
fn ast_tup_elem_to_str(&tup(mutability, @ast.ty) elem) -> str {
6970
auto s;
70-
if (elem._0) {
71+
if (elem._0 == ast.mut) {
7172
s = "mutable ";
7273
} else {
7374
s = "";
@@ -102,7 +103,9 @@ fn ast_ty_to_str(&@ast.ty ty) -> str {
102103
case (ast.ty_tup(?elems)) {
103104
auto f = ast_tup_elem_to_str;
104105
s = "tup(";
105-
s += _str.connect(_vec.map[tup(bool,@ast.ty),str](f, elems), ",");
106+
s +=
107+
_str.connect(_vec.map[tup(mutability,@ast.ty),str](f, elems),
108+
",");
106109
s += ")";
107110
}
108111

@@ -151,9 +154,9 @@ fn path_to_str(&ast.path path) -> str {
151154
}
152155

153156
fn ty_to_str(@ty typ) -> str {
154-
fn tup_elem_to_str(&tup(bool, @ty) elem) -> str {
157+
fn tup_elem_to_str(&tup(mutability, @ty) elem) -> str {
155158
auto s;
156-
if (elem._0) {
159+
if (elem._0 == ast.mut) {
157160
s = "mutable ";
158161
} else {
159162
s = "";
@@ -187,7 +190,7 @@ fn ty_to_str(@ty typ) -> str {
187190

188191
case (ty_tup(?elems)) {
189192
auto f = tup_elem_to_str;
190-
auto strs = _vec.map[tup(bool,@ty),str](f, elems);
193+
auto strs = _vec.map[tup(mutability,@ty),str](f, elems);
191194
s = "tup(" + _str.connect(strs, ",") + ")";
192195
}
193196

@@ -217,7 +220,7 @@ fn ast_ty_to_ty(ty_getter getter, &@ast.ty ast_ty) -> @ty {
217220
ret rec(mode=arg.mode, ty=ast_ty_to_ty(getter, arg.ty));
218221
}
219222

220-
auto mut = false;
223+
auto mut = ast.imm;
221224
auto sty;
222225
auto cname = none[str];
223226
alt (ast_ty.node) {
@@ -231,8 +234,8 @@ fn ast_ty_to_ty(ty_getter getter, &@ast.ty ast_ty) -> @ty {
231234
case (ast.ty_box(?t)) { sty = ty_box(ast_ty_to_ty(getter, t)); }
232235
case (ast.ty_vec(?t)) { sty = ty_vec(ast_ty_to_ty(getter, t)); }
233236
case (ast.ty_tup(?fields)) {
234-
let vec[tup(bool,@ty)] flds = vec();
235-
for (tup(bool, @ast.ty) field in fields) {
237+
let vec[tup(mutability,@ty)] flds = vec();
238+
for (tup(mutability, @ast.ty) field in fields) {
236239
flds += tup(field._0, ast_ty_to_ty(getter, field._1));
237240
}
238241
sty = ty_tup(flds);
@@ -258,7 +261,7 @@ fn ast_ty_to_ty(ty_getter getter, &@ast.ty ast_ty) -> @ty {
258261
}
259262

260263
case (ast.ty_mutable(?t)) {
261-
mut = true;
264+
mut = ast.mut;
262265
auto t0 = ast_ty_to_ty(getter, t);
263266
sty = t0.struct;
264267
cname = t0.cname;
@@ -534,7 +537,7 @@ fn type_is_signed(@ty t) -> bool {
534537
}
535538

536539
fn plain_ty(&sty st) -> @ty {
537-
ret @rec(struct=st, mut=false, cname=none[str]);
540+
ret @rec(struct=st, mut=ast.imm, cname=none[str]);
538541
}
539542

540543
fn ann_to_type(&ast.ann ann) -> @ty {
@@ -708,9 +711,9 @@ fn unify(&fn_ctxt fcx, @ty expected, @ty actual) -> unify_result {
708711
alt (actual.struct) {
709712
case (ty_tup(?actual_elems)) {
710713
auto expected_len =
711-
_vec.len[tup(bool,@ty)](expected_elems);
714+
_vec.len[tup(mutability,@ty)](expected_elems);
712715
auto actual_len =
713-
_vec.len[tup(bool,@ty)](actual_elems);
716+
_vec.len[tup(mutability,@ty)](actual_elems);
714717
if (expected_len != actual_len) {
715718
auto err = terr_tuple_size(expected_len,
716719
actual_len);
@@ -719,7 +722,7 @@ fn unify(&fn_ctxt fcx, @ty expected, @ty actual) -> unify_result {
719722

720723
// TODO: implement an iterator that can iterate over
721724
// two arrays simultaneously.
722-
let vec[tup(bool, @ty)] result_elems = vec();
725+
let vec[tup(mutability, @ty)] result_elems = vec();
723726
auto i = 0u;
724727
while (i < expected_len) {
725728
auto expected_elem = expected_elems.(i);
@@ -1254,10 +1257,10 @@ fn check_expr(&fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
12541257
}
12551258

12561259
case (ast.expr_tup(?args, _)) {
1257-
let vec[tup(bool, @ast.expr)] args_1 = vec();
1258-
let vec[tup(bool, @ty)] args_t = vec();
1260+
let vec[tup(mutability, @ast.expr)] args_1 = vec();
1261+
let vec[tup(mutability, @ty)] args_t = vec();
12591262

1260-
for (tup(bool, @ast.expr) arg in args) {
1263+
for (tup(mutability, @ast.expr) arg in args) {
12611264
auto expr_1 = check_expr(fcx, arg._1);
12621265
args_1 += tup(arg._0, expr_1);
12631266
args_t += tup(arg._0, expr_ty(expr_1));
@@ -1275,7 +1278,7 @@ fn check_expr(&fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
12751278
case (ty_tup(?args)) {
12761279
let uint ix = field_num(fcx.ccx.sess,
12771280
expr.span, field);
1278-
if (ix >= _vec.len[tup(bool,@ty)](args)) {
1281+
if (ix >= _vec.len[tup(mutability,@ty)](args)) {
12791282
fcx.ccx.sess.span_err(expr.span,
12801283
"bad index on tuple");
12811284
}

0 commit comments

Comments
 (0)