Skip to content

Commit 34c60b6

Browse files
graydongraydon
committed
Make a tag for iterness / fnness, teach many places about it.
1 parent 3aba50f commit 34c60b6

File tree

6 files changed

+303
-228
lines changed

6 files changed

+303
-228
lines changed

‎src/comp/front/ast.rs

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -78,6 +78,11 @@ tag effect {
7878
eff_unsafe;
7979
}
8080

81+
tag proto {
82+
proto_iter;
83+
proto_fn;
84+
}
85+
8186
tag binop {
8287
add;
8388
sub;
@@ -187,7 +192,8 @@ tag lit_ {
187192
type ty_field = rec(ident ident, @ty ty);
188193
type ty_arg = rec(mode mode, @ty ty);
189194
// TODO: effect
190-
type ty_method = rec(ident ident, vec[ty_arg] inputs, @ty output);
195+
type ty_method = rec(proto proto, ident ident,
196+
vec[ty_arg] inputs, @ty output);
191197
type ty = spanned[ty_];
192198
tag ty_ {
193199
ty_nil;
@@ -201,7 +207,7 @@ tag ty_ {
201207
ty_vec(@ty);
202208
ty_tup(vec[@ty]);
203209
ty_rec(vec[ty_field]);
204-
ty_fn(vec[ty_arg], @ty); // TODO: effect
210+
ty_fn(proto, vec[ty_arg], @ty); // TODO: effect
205211
ty_obj(vec[ty_method]);
206212
ty_path(path, option.t[def]);
207213
ty_mutable(@ty);
@@ -210,10 +216,10 @@ tag ty_ {
210216

211217
type arg = rec(mode mode, @ty ty, ident ident, def_id id);
212218
type fn_decl = rec(effect effect,
219+
proto proto,
213220
vec[arg] inputs,
214221
@ty output);
215222
type _fn = rec(fn_decl decl,
216-
bool is_iter,
217223
block body);
218224

219225

‎src/comp/front/parser.rs

Lines changed: 51 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,8 @@ impure fn parse_str_lit(parser p) -> ast.ident {
133133
}
134134

135135

136-
impure fn parse_ty_fn(parser p, ast.span lo) -> ast.ty_ {
136+
impure fn parse_ty_fn(ast.proto proto, parser p,
137+
ast.span lo) -> ast.ty_ {
137138
impure fn parse_fn_input_ty(parser p) -> rec(ast.mode mode, @ast.ty ty) {
138139
auto mode;
139140
if (p.peek() == token.BINOP(token.AND)) {
@@ -167,7 +168,16 @@ impure fn parse_ty_fn(parser p, ast.span lo) -> ast.ty_ {
167168
output = @spanned(lo, inputs.span, ast.ty_nil);
168169
}
169170

170-
ret ast.ty_fn(inputs.node, output);
171+
ret ast.ty_fn(proto, inputs.node, output);
172+
}
173+
174+
impure fn parse_proto(parser p) -> ast.proto {
175+
alt (p.peek()) {
176+
case (token.ITER) { p.bump(); ret ast.proto_iter; }
177+
case (token.FN) { p.bump(); ret ast.proto_fn; }
178+
case (?t) { unexpected(p, t); }
179+
}
180+
fail;
171181
}
172182

173183
impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ {
@@ -177,14 +187,14 @@ impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ {
177187

178188
// FIXME: do something with this, currently it's dropped on the floor.
179189
let ast.effect eff = parse_effect(p);
180-
181-
expect(p, token.FN);
190+
let ast.proto proto = parse_proto(p);
182191
auto ident = parse_ident(p);
183-
auto f = parse_ty_fn(p, flo);
192+
auto f = parse_ty_fn(proto, p, flo);
184193
expect(p, token.SEMI);
185194
alt (f) {
186-
case (ast.ty_fn(?inputs, ?output)) {
187-
ret rec(ident=ident, inputs=inputs, output=output);
195+
case (ast.ty_fn(?proto, ?inputs, ?output)) {
196+
ret rec(proto=proto, ident=ident,
197+
inputs=inputs, output=output);
188198
}
189199
}
190200
fail;
@@ -286,9 +296,20 @@ impure fn parse_ty(parser p) -> @ast.ty {
286296
case (token.FN) {
287297
auto flo = p.get_span();
288298
p.bump();
289-
t = parse_ty_fn(p, flo);
299+
t = parse_ty_fn(ast.proto_fn, p, flo);
290300
alt (t) {
291-
case (ast.ty_fn(_, ?out)) {
301+
case (ast.ty_fn(_, _, ?out)) {
302+
hi = out.span;
303+
}
304+
}
305+
}
306+
307+
case (token.ITER) {
308+
auto flo = p.get_span();
309+
p.bump();
310+
t = parse_ty_fn(ast.proto_iter, p, flo);
311+
alt (t) {
312+
case (ast.ty_fn(_, _, ?out)) {
292313
hi = out.span;
293314
}
294315
}
@@ -1537,7 +1558,8 @@ impure fn parse_ty_params(parser p) -> vec[ast.ty_param] {
15371558
ret ty_params;
15381559
}
15391560

1540-
impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl {
1561+
impure fn parse_fn_decl(parser p, ast.proto proto,
1562+
ast.effect eff) -> ast.fn_decl {
15411563
auto pf = parse_arg;
15421564
let util.common.spanned[vec[ast.arg]] inputs =
15431565
// FIXME: passing parse_arg as an lval doesn't work at the
@@ -1555,35 +1577,30 @@ impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl {
15551577
} else {
15561578
output = @spanned(inputs.span, inputs.span, ast.ty_nil);
15571579
}
1558-
ret rec(effect=eff, inputs=inputs.node, output=output);
1580+
ret rec(effect=eff, proto=proto,
1581+
inputs=inputs.node, output=output);
15591582
}
15601583

1561-
impure fn parse_fn(parser p, ast.effect eff, bool is_iter) -> ast._fn {
1562-
auto decl = parse_fn_decl(p, eff);
1584+
impure fn parse_fn(parser p, ast.effect eff, ast.proto proto) -> ast._fn {
1585+
auto decl = parse_fn_decl(p, proto, eff);
15631586
auto body = parse_block(p);
15641587
ret rec(decl = decl,
1565-
is_iter = is_iter,
15661588
body = body);
15671589
}
15681590

1569-
impure fn parse_fn_header(parser p, bool is_iter) -> tup(span, ast.ident,
1570-
vec[ast.ty_param]) {
1591+
impure fn parse_fn_header(parser p)
1592+
-> tup(span, ast.proto, ast.ident, vec[ast.ty_param]) {
15711593
auto lo = p.get_span();
1572-
if (is_iter) {
1573-
expect(p, token.ITER);
1574-
} else {
1575-
expect(p, token.FN);
1576-
}
1594+
auto proto = parse_proto(p);
15771595
auto id = parse_ident(p);
15781596
auto ty_params = parse_ty_params(p);
1579-
ret tup(lo, id, ty_params);
1597+
ret tup(lo, proto, id, ty_params);
15801598
}
15811599

1582-
impure fn parse_item_fn_or_iter(parser p, ast.effect eff,
1583-
bool is_iter) -> @ast.item {
1584-
auto t = parse_fn_header(p, is_iter);
1585-
auto f = parse_fn(p, eff, is_iter);
1586-
auto item = ast.item_fn(t._1, f, t._2,
1600+
impure fn parse_item_fn_or_iter(parser p, ast.effect eff) -> @ast.item {
1601+
auto t = parse_fn_header(p);
1602+
auto f = parse_fn(p, eff, t._1);
1603+
auto item = ast.item_fn(t._2, f, t._3,
15871604
p.next_def_id(), ast.ann_none);
15881605
ret @spanned(t._0, f.body.span, item);
15891606
}
@@ -1598,14 +1615,9 @@ impure fn parse_obj_field(parser p) -> ast.obj_field {
15981615
impure fn parse_method(parser p) -> @ast.method {
15991616
auto lo = p.get_span();
16001617
auto eff = parse_effect(p);
1601-
auto is_iter = false;
1602-
alt (p.peek()) {
1603-
case (token.FN) { p.bump(); }
1604-
case (token.ITER) { p.bump(); is_iter = true; }
1605-
case (?t) { unexpected(p, t); }
1606-
}
1618+
auto proto = parse_proto(p);
16071619
auto ident = parse_ident(p);
1608-
auto f = parse_fn(p, eff, is_iter);
1620+
auto f = parse_fn(p, eff, proto);
16091621
auto meth = rec(ident=ident, meth=f,
16101622
id=p.next_def_id(), ann=ast.ann_none);
16111623
ret @spanned(lo, f.body.span, meth);
@@ -1689,11 +1701,11 @@ impure fn parse_item_native_type(parser p) -> @ast.native_item {
16891701
}
16901702

16911703
impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item {
1692-
auto t = parse_fn_header(p, false);
1693-
auto decl = parse_fn_decl(p, eff);
1704+
auto t = parse_fn_header(p);
1705+
auto decl = parse_fn_decl(p, t._1, eff);
16941706
auto hi = p.get_span();
16951707
expect(p, token.SEMI);
1696-
auto item = ast.native_item_fn(t._1, decl, t._2, p.next_def_id(),
1708+
auto item = ast.native_item_fn(t._2, decl, t._3, p.next_def_id(),
16971709
ast.ann_none);
16981710
ret @spanned(t._0, hi, item);
16991711
}
@@ -1883,11 +1895,11 @@ impure fn parse_item(parser p) -> @ast.item {
18831895

18841896
case (token.FN) {
18851897
check (lyr == ast.layer_value);
1886-
ret parse_item_fn_or_iter(p, eff, false);
1898+
ret parse_item_fn_or_iter(p, eff);
18871899
}
18881900
case (token.ITER) {
18891901
check (lyr == ast.layer_value);
1890-
ret parse_item_fn_or_iter(p, eff, true);
1902+
ret parse_item_fn_or_iter(p, eff);
18911903
}
18921904
case (token.MOD) {
18931905
check (eff == ast.eff_pure);

‎src/comp/middle/fold.rs

Lines changed: 21 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,7 @@ type ast_fold[ENV] =
5959
vec[ast.ty_method] meths) -> @ty) fold_ty_obj,
6060

6161
(fn(&ENV e, &span sp,
62+
ast.proto proto,
6263
vec[rec(ast.mode mode, @ty ty)] inputs,
6364
@ty output) -> @ty) fold_ty_fn,
6465

@@ -252,11 +253,10 @@ type ast_fold[ENV] =
252253
&ast.block_) -> block) fold_block,
253254

254255
(fn(&ENV e, &fn_decl decl,
255-
bool is_iter,
256256
&block body) -> ast._fn) fold_fn,
257257

258258
(fn(&ENV e, ast.effect effect,
259-
vec[arg] inputs,
259+
ast.proto proto, vec[arg] inputs,
260260
@ty output) -> ast.fn_decl) fold_fn_decl,
261261

262262
(fn(&ENV e, &ast._mod m) -> ast._mod) fold_mod,
@@ -349,11 +349,13 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
349349
case (ast.ty_obj(?meths)) {
350350
let vec[ast.ty_method] meths_ = vec();
351351
for (ast.ty_method m in meths) {
352-
auto tfn = fold_ty_fn(env_, fld, t.span, m.inputs, m.output);
352+
auto tfn = fold_ty_fn(env_, fld, t.span, m.proto,
353+
m.inputs, m.output);
353354
alt (tfn.node) {
354-
case (ast.ty_fn(?ins, ?out)) {
355+
case (ast.ty_fn(?p, ?ins, ?out)) {
355356
append[ast.ty_method]
356-
(meths_, rec(inputs=ins, output=out with m));
357+
(meths_, rec(proto=p, inputs=ins, output=out
358+
with m));
357359
}
358360
}
359361
}
@@ -370,13 +372,14 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
370372
ret fld.fold_ty_mutable(env_, t.span, ty_);
371373
}
372374

373-
case (ast.ty_fn(?inputs, ?output)) {
374-
ret fold_ty_fn(env_, fld, t.span, inputs, output);
375+
case (ast.ty_fn(?proto, ?inputs, ?output)) {
376+
ret fold_ty_fn(env_, fld, t.span, proto, inputs, output);
375377
}
376378
}
377379
}
378380

379381
fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp,
382+
ast.proto proto,
380383
vec[rec(ast.mode mode, @ty ty)] inputs,
381384
@ty output) -> @ty {
382385
auto output_ = fold_ty(env, fld, output);
@@ -386,7 +389,7 @@ fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp,
386389
auto input_ = rec(ty=ty_ with input);
387390
inputs_ += vec(input_);
388391
}
389-
ret fld.fold_ty_fn(env, sp, inputs_, output_);
392+
ret fld.fold_ty_fn(env, sp, proto, inputs_, output_);
390393
}
391394

392395
fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl {
@@ -754,15 +757,15 @@ fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld,
754757
inputs += fold_arg(env, fld, a);
755758
}
756759
auto output = fold_ty[ENV](env, fld, decl.output);
757-
ret fld.fold_fn_decl(env, decl.effect, inputs, output);
760+
ret fld.fold_fn_decl(env, decl.effect, decl.proto, inputs, output);
758761
}
759762

760763
fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
761764
auto decl = fold_fn_decl(env, fld, f.decl);
762765

763766
auto body = fold_block[ENV](env, fld, f.body);
764767

765-
ret fld.fold_fn(env, decl, f.is_iter, body);
768+
ret fld.fold_fn(env, decl, body);
766769
}
767770

768771

@@ -1019,9 +1022,10 @@ fn identity_fold_ty_obj[ENV](&ENV env, &span sp,
10191022
}
10201023

10211024
fn identity_fold_ty_fn[ENV](&ENV env, &span sp,
1025+
ast.proto proto,
10221026
vec[rec(ast.mode mode, @ty ty)] inputs,
10231027
@ty output) -> @ty {
1024-
ret @respan(sp, ast.ty_fn(inputs, output));
1028+
ret @respan(sp, ast.ty_fn(proto, inputs, output));
10251029
}
10261030

10271031
fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p,
@@ -1301,16 +1305,16 @@ fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block {
13011305

13021306
fn identity_fold_fn_decl[ENV](&ENV e,
13031307
ast.effect effect,
1308+
ast.proto proto,
13041309
vec[arg] inputs,
13051310
@ty output) -> ast.fn_decl {
1306-
ret rec(effect=effect, inputs=inputs, output=output);
1311+
ret rec(effect=effect, proto=proto, inputs=inputs, output=output);
13071312
}
13081313

13091314
fn identity_fold_fn[ENV](&ENV e,
13101315
&fn_decl decl,
1311-
bool is_iter,
13121316
&block body) -> ast._fn {
1313-
ret rec(decl=decl, is_iter=is_iter, body=body);
1317+
ret rec(decl=decl, body=body);
13141318
}
13151319

13161320
fn identity_fold_mod[ENV](&ENV e, &ast._mod m) -> ast._mod {
@@ -1404,7 +1408,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
14041408
fold_ty_tup = bind identity_fold_ty_tup[ENV](_,_,_),
14051409
fold_ty_rec = bind identity_fold_ty_rec[ENV](_,_,_),
14061410
fold_ty_obj = bind identity_fold_ty_obj[ENV](_,_,_),
1407-
fold_ty_fn = bind identity_fold_ty_fn[ENV](_,_,_,_),
1411+
fold_ty_fn = bind identity_fold_ty_fn[ENV](_,_,_,_,_),
14081412
fold_ty_path = bind identity_fold_ty_path[ENV](_,_,_,_),
14091413
fold_ty_mutable = bind identity_fold_ty_mutable[ENV](_,_,_),
14101414

@@ -1470,8 +1474,8 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
14701474
bind identity_fold_view_item_import[ENV](_,_,_,_,_,_),
14711475

14721476
fold_block = bind identity_fold_block[ENV](_,_,_),
1473-
fold_fn = bind identity_fold_fn[ENV](_,_,_,_),
1474-
fold_fn_decl = bind identity_fold_fn_decl[ENV](_,_,_,_),
1477+
fold_fn = bind identity_fold_fn[ENV](_,_,_),
1478+
fold_fn_decl = bind identity_fold_fn_decl[ENV](_,_,_,_,_),
14751479
fold_mod = bind identity_fold_mod[ENV](_,_),
14761480
fold_native_mod = bind identity_fold_native_mod[ENV](_,_),
14771481
fold_crate = bind identity_fold_crate[ENV](_,_,_),

0 commit comments

Comments
 (0)