Skip to content

Commit 2b27d12

Browse files
brsongraydon
brson
authored and
graydon
committed
Add expr_spawn, spawn parsing, folding, typechecking, ty_task
1 parent db5c809 commit 2b27d12

File tree

5 files changed

+107
-16
lines changed

5 files changed

+107
-16
lines changed

‎src/comp/front/ast.rs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -219,13 +219,19 @@ type arm = rec(@pat pat, block block, hashmap[ident,def_id] index);
219219
type elt = rec(mutability mut, @expr expr);
220220
type field = rec(mutability mut, ident ident, @expr expr);
221221
222+
tag spawn_dom {
223+
dom_implicit;
224+
dom_thread;
225+
}
226+
222227
type expr = spanned[expr_];
223228
tag expr_ {
224229
expr_vec(vec[@expr], mutability, ann);
225230
expr_tup(vec[elt], ann);
226231
expr_rec(vec[field], option.t[@expr], ann);
227232
expr_call(@expr, vec[@expr], ann);
228233
expr_bind(@expr, vec[option.t[@expr]], ann);
234+
expr_spawn(spawn_dom, option.t[str], @expr, vec[@expr], ann);
229235
expr_binary(binop, @expr, @expr, ann);
230236
expr_unary(unop, @expr, ann);
231237
expr_lit(@lit, ann);

‎src/comp/front/parser.rs

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1333,6 +1333,27 @@ impure fn parse_alt_expr(parser p) -> @ast.expr {
13331333
ret @spanned(lo, hi, expr);
13341334
}
13351335

1336+
impure fn parse_spawn_expr(parser p) -> @ast.expr {
1337+
auto lo = p.get_span();
1338+
expect(p, token.SPAWN);
1339+
1340+
// FIXME: Parse domain and name
1341+
1342+
auto fn_expr = parse_bottom_expr(p);
1343+
auto pf = parse_expr;
1344+
auto es = parse_seq[@ast.expr](token.LPAREN,
1345+
token.RPAREN,
1346+
some(token.COMMA),
1347+
pf, p);
1348+
auto hi = es.span;
1349+
auto spawn_expr = ast.expr_spawn(ast.dom_implicit,
1350+
option.none[str],
1351+
fn_expr,
1352+
es.node,
1353+
ast.ann_none);
1354+
ret @spanned(lo, hi, spawn_expr);
1355+
}
1356+
13361357
impure fn parse_expr(parser p) -> @ast.expr {
13371358
ret parse_expr_res(p, UNRESTRICTED);
13381359
}
@@ -1367,6 +1388,9 @@ impure fn parse_expr_inner(parser p) -> @ast.expr {
13671388
case (token.ALT) {
13681389
ret parse_alt_expr(p);
13691390
}
1391+
case (token.SPAWN) {
1392+
ret parse_spawn_expr(p);
1393+
}
13701394
case (_) {
13711395
ret parse_assign_expr(p);
13721396
}

‎src/comp/middle/fold.rs

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,11 @@ type ast_fold[ENV] =
9090
@expr f, vec[option.t[@expr]] args,
9191
ann a) -> @expr) fold_expr_bind,
9292

93+
(fn(&ENV e, &span sp,
94+
ast.spawn_dom dom, option.t[str] name,
95+
@expr f, vec[@expr] args,
96+
ann a) -> @expr) fold_expr_spawn,
97+
9398
(fn(&ENV e, &span sp,
9499
ast.binop,
95100
@expr lhs, @expr rhs,
@@ -573,6 +578,12 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
573578
ret fld.fold_expr_bind(env_, e.span, ff, aargs_opt, t);
574579
}
575580

581+
case (ast.expr_spawn(?dom, ?name, ?f, ?args, ?t)) {
582+
auto ff = fold_expr(env_, fld, f);
583+
auto aargs = fold_exprs(env_, fld, args);
584+
ret fld.fold_expr_spawn(env_, e.span, dom, name, ff, aargs, t);
585+
}
586+
576587
case (ast.expr_binary(?op, ?a, ?b, ?t)) {
577588
auto aa = fold_expr(env_, fld, a);
578589
auto bb = fold_expr(env_, fld, b);
@@ -1168,6 +1179,12 @@ fn identity_fold_expr_bind[ENV](&ENV env, &span sp, @expr f,
11681179
ret @respan(sp, ast.expr_bind(f, args_opt, a));
11691180
}
11701181

1182+
fn identity_fold_expr_spawn[ENV](&ENV env, &span sp,
1183+
ast.spawn_dom dom, option.t[str] name,
1184+
@expr f, vec[@expr] args, ann a) -> @expr {
1185+
ret @respan(sp, ast.expr_spawn(dom, name, f, args, a));
1186+
}
1187+
11711188
fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b,
11721189
@expr lhs, @expr rhs,
11731190
ann a) -> @expr {
@@ -1562,6 +1579,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
15621579
fold_expr_rec = bind identity_fold_expr_rec[ENV](_,_,_,_,_),
15631580
fold_expr_call = bind identity_fold_expr_call[ENV](_,_,_,_,_),
15641581
fold_expr_bind = bind identity_fold_expr_bind[ENV](_,_,_,_,_),
1582+
fold_expr_spawn = bind identity_fold_expr_spawn[ENV](_,_,_,_,_,_,_),
15651583
fold_expr_binary = bind identity_fold_expr_binary[ENV](_,_,_,_,_,_),
15661584
fold_expr_unary = bind identity_fold_expr_unary[ENV](_,_,_,_,_),
15671585
fold_expr_lit = bind identity_fold_expr_lit[ENV](_,_,_,_),

‎src/comp/middle/ty.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ tag sty {
4242
ty_vec(mt);
4343
ty_port(@t);
4444
ty_chan(@t);
45+
ty_task;
4546
ty_tup(vec[mt]);
4647
ty_rec(vec[field]);
4748
ty_fn(ast.proto, vec[arg], @t); // TODO: effect
@@ -756,6 +757,8 @@ fn expr_ty(@ast.expr expr) -> @t {
756757
case (ast.expr_rec(_, _, ?ann)) { ret ann_to_type(ann); }
757758
case (ast.expr_bind(_, _, ?ann)) { ret ann_to_type(ann); }
758759
case (ast.expr_call(_, _, ?ann)) { ret ann_to_type(ann); }
760+
case (ast.expr_spawn(_, _, _, _, ?ann))
761+
{ ret ann_to_type(ann); }
759762
case (ast.expr_binary(_, _, _, ?ann)) { ret ann_to_type(ann); }
760763
case (ast.expr_unary(_, _, ?ann)) { ret ann_to_type(ann); }
761764
case (ast.expr_lit(_, ?ann)) { ret ann_to_type(ann); }

‎src/comp/middle/typeck.rs

Lines changed: 56 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1750,6 +1750,27 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
17501750
ret tup(lhs_1, rhs_1, ann);
17511751
}
17521752

1753+
// A generic function for checking call expressions
1754+
fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args)
1755+
-> tup(@ast.expr, vec[@ast.expr]) {
1756+
1757+
let vec[option.t[@ast.expr]] args_opt_0 = vec();
1758+
for (@ast.expr arg in args) {
1759+
args_opt_0 += vec(some[@ast.expr](arg));
1760+
}
1761+
1762+
// Call the generic checker.
1763+
auto result = check_call_or_bind(fcx, f, args_opt_0);
1764+
1765+
// Pull out the arguments.
1766+
let vec[@ast.expr] args_1 = vec();
1767+
for (option.t[@ast.expr] arg in result._1) {
1768+
args_1 += vec(option.get[@ast.expr](arg));
1769+
}
1770+
1771+
ret tup(result._0, args_1);
1772+
}
1773+
17531774
alt (expr.node) {
17541775
case (ast.expr_lit(?lit, _)) {
17551776
auto typ = check_lit(lit);
@@ -2154,23 +2175,13 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
21542175
}
21552176

21562177
case (ast.expr_call(?f, ?args, _)) {
2157-
let vec[option.t[@ast.expr]] args_opt_0 = vec();
2158-
for (@ast.expr arg in args) {
2159-
args_opt_0 += vec(some[@ast.expr](arg));
2160-
}
2161-
2162-
// Call the generic checker.
2163-
auto result = check_call_or_bind(fcx, f, args_opt_0);
2164-
2165-
// Pull out the arguments.
2166-
let vec[@ast.expr] args_1 = vec();
2167-
for (option.t[@ast.expr] arg in result._1) {
2168-
args_1 += vec(option.get[@ast.expr](arg));
2169-
}
2178+
auto result = check_call(fcx, f, args);
2179+
auto f_1 = result._0;
2180+
auto args_1 = result._1;
21702181

21712182
// Pull the return type out of the type of the function.
21722183
auto rt_1 = plain_ty(ty.ty_nil); // FIXME: typestate botch
2173-
alt (expr_ty(result._0).struct) {
2184+
alt (expr_ty(f_1).struct) {
21742185
case (ty.ty_fn(_,_,?rt)) { rt_1 = rt; }
21752186
case (ty.ty_native_fn(_, _, ?rt)) { rt_1 = rt; }
21762187
case (_) {
@@ -2181,8 +2192,37 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
21812192

21822193
auto ann = ast.ann_type(rt_1, none[vec[@ty.t]]);
21832194
ret @fold.respan[ast.expr_](expr.span,
2184-
ast.expr_call(result._0, args_1,
2185-
ann));
2195+
ast.expr_call(f_1, args_1, ann));
2196+
}
2197+
2198+
case (ast.expr_spawn(?dom, ?name, ?f, ?args, _)) {
2199+
auto result = check_call(fcx, f, args);
2200+
auto f_1 = result._0;
2201+
auto args_1 = result._1;
2202+
2203+
// Check the return type
2204+
alt (expr_ty(f_1).struct) {
2205+
case (ty.ty_fn(_,_,?rt)) {
2206+
alt (rt.struct) {
2207+
case (ty.ty_nil) {
2208+
// This is acceptable
2209+
}
2210+
case (_) {
2211+
auto err = "non-nil return type in "
2212+
+ "spawned function";
2213+
fcx.ccx.sess.span_err(expr.span, err);
2214+
fail;
2215+
}
2216+
}
2217+
}
2218+
}
2219+
2220+
// FIXME: Other typechecks needed
2221+
2222+
auto ann = ast.ann_type(plain_ty(ty.ty_task), none[vec[@ty.t]]);
2223+
ret @fold.respan[ast.expr_](expr.span,
2224+
ast.expr_spawn(dom, name,
2225+
f_1, args_1, ann));
21862226
}
21872227

21882228
case (ast.expr_cast(?e, ?t, _)) {

0 commit comments

Comments
 (0)