Skip to content

Commit c34e9b3

Browse files
marijnhmarijnh
committed
Move expr ids into the expr record type
This simplifies the tag variants a bit and makes expr_node_id obsolete.
1 parent edf73f0 commit c34e9b3

20 files changed

+814
-938
lines changed

‎src/comp/front/ast.rs

Lines changed: 48 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -220,61 +220,63 @@ tag spawn_dom { dom_implicit; dom_thread; }
220220
// FIXME: temporary
221221
tag seq_kind { sk_unique; sk_rc; }
222222
223-
type expr = spanned[expr_];
223+
type expr = rec(node_id id,
224+
expr_ node,
225+
span span);
224226
225227
tag expr_ {
226-
expr_vec(vec[@expr], mutability, seq_kind, node_id);
227-
expr_tup(vec[elt], node_id);
228-
expr_rec(vec[field], option::t[@expr], node_id);
229-
expr_call(@expr, vec[@expr], node_id);
230-
expr_self_method(ident, node_id);
231-
expr_bind(@expr, vec[option::t[@expr]], node_id);
232-
expr_spawn(spawn_dom, option::t[str], @expr, vec[@expr], node_id);
233-
expr_binary(binop, @expr, @expr, node_id);
234-
expr_unary(unop, @expr, node_id);
235-
expr_lit(@lit, node_id);
236-
expr_cast(@expr, @ty, node_id);
237-
expr_if(@expr, block, option::t[@expr], node_id);
238-
expr_while(@expr, block, node_id);
239-
expr_for(@local, @expr, block, node_id);
240-
expr_for_each(@local, @expr, block, node_id);
241-
expr_do_while(block, @expr, node_id);
242-
expr_alt(@expr, vec[arm], node_id);
243-
expr_fn(_fn, node_id);
244-
expr_block(block, node_id);
228+
expr_vec(vec[@expr], mutability, seq_kind);
229+
expr_tup(vec[elt]);
230+
expr_rec(vec[field], option::t[@expr]);
231+
expr_call(@expr, vec[@expr]);
232+
expr_self_method(ident);
233+
expr_bind(@expr, vec[option::t[@expr]]);
234+
expr_spawn(spawn_dom, option::t[str], @expr, vec[@expr]);
235+
expr_binary(binop, @expr, @expr);
236+
expr_unary(unop, @expr);
237+
expr_lit(@lit);
238+
expr_cast(@expr, @ty);
239+
expr_if(@expr, block, option::t[@expr]);
240+
expr_while(@expr, block);
241+
expr_for(@local, @expr, block);
242+
expr_for_each(@local, @expr, block);
243+
expr_do_while(block, @expr);
244+
expr_alt(@expr, vec[arm]);
245+
expr_fn(_fn);
246+
expr_block(block);
245247
/*
246248
* FIXME: many of these @exprs should be constrained with
247249
* is_lval once we have constrained types working.
248250
*/
249-
expr_move(@expr, @expr, node_id);
250-
expr_assign(@expr,@expr, node_id);
251-
expr_swap(@expr, @expr, node_id);
252-
expr_assign_op(binop, @expr, @expr, node_id);
253-
expr_send(@expr, @expr, node_id);
254-
expr_recv(@expr, @expr, node_id);
255-
expr_field(@expr, ident, node_id);
256-
expr_index(@expr, @expr, node_id);
257-
expr_path(path, node_id);
258-
expr_ext(path, vec[@expr], option::t[str], @expr, node_id);
259-
expr_fail(node_id, option::t[str]);
260-
expr_break(node_id);
261-
expr_cont(node_id);
262-
expr_ret(option::t[@expr], node_id);
263-
expr_put(option::t[@expr], node_id);
264-
expr_be(@expr, node_id);
265-
expr_log(int, @expr, node_id);
251+
expr_move(@expr, @expr);
252+
expr_assign(@expr,@expr);
253+
expr_swap(@expr, @expr);
254+
expr_assign_op(binop, @expr, @expr);
255+
expr_send(@expr, @expr);
256+
expr_recv(@expr, @expr);
257+
expr_field(@expr, ident);
258+
expr_index(@expr, @expr);
259+
expr_path(path);
260+
expr_ext(path, vec[@expr], option::t[str], @expr);
261+
expr_fail(option::t[str]);
262+
expr_break;
263+
expr_cont;
264+
expr_ret(option::t[@expr]);
265+
expr_put(option::t[@expr]);
266+
expr_be(@expr);
267+
expr_log(int, @expr);
266268
267269
/* just an assert, no significance to typestate */
268-
expr_assert(@expr, node_id);
270+
expr_assert(@expr);
269271
270272
/* preds that typestate is aware of */
271-
expr_check(@expr, node_id);
273+
expr_check(@expr);
272274
/* FIXME Would be nice if expr_check desugared
273275
to expr_if_check. */
274-
expr_if_check(@expr, block, option::t[@expr], node_id);
275-
expr_port(node_id);
276-
expr_chan(@expr, node_id);
277-
expr_anon_obj(anon_obj, vec[ty_param], obj_def_ids, node_id);
276+
expr_if_check(@expr, block, option::t[@expr]);
277+
expr_port;
278+
expr_chan(@expr);
279+
expr_anon_obj(anon_obj, vec[ty_param], obj_def_ids);
278280
}
279281
280282
type lit = spanned[lit_];
@@ -527,15 +529,15 @@ fn is_exported(ident i, _mod m) -> bool {
527529

528530
fn is_call_expr(@expr e) -> bool {
529531
alt (e.node) {
530-
case (expr_call(_, _, _)) { ret true; }
532+
case (expr_call(_, _)) { ret true; }
531533
case (_) { ret false; }
532534
}
533535
}
534536

535537
fn is_constraint_arg(@expr e) -> bool {
536538
alt (e.node) {
537-
case (expr_lit(_, _)) { ret true; }
538-
case (expr_path(_, _)) { ret true; }
539+
case (expr_lit(_)) { ret true; }
540+
case (expr_path(_)) { ret true; }
539541
case (_) { ret false; }
540542
}
541543
}

‎src/comp/front/eval.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -77,15 +77,15 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
7777

7878
fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
7979
alt (x.node) {
80-
case (ast::expr_path(?pth, _)) {
80+
case (ast::expr_path(?pth)) {
8181
if (vec::len[ident](pth.node.idents) == 1u &&
8282
vec::len[@ast::ty](pth.node.types) == 0u) {
8383
ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
8484
}
8585
cx.sess.span_fatal(x.span, "evaluating structured path-name");
8686
}
87-
case (ast::expr_lit(?lit, _)) { ret eval_lit(cx, x.span, lit); }
88-
case (ast::expr_unary(?op, ?a, _)) {
87+
case (ast::expr_lit(?lit)) { ret eval_lit(cx, x.span, lit); }
88+
case (ast::expr_unary(?op, ?a)) {
8989
auto av = eval_expr(cx, e, a);
9090
alt (op) {
9191
case (ast::not) {
@@ -97,7 +97,7 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
9797
}
9898
}
9999
}
100-
case (ast::expr_binary(?op, ?a, ?b, _)) {
100+
case (ast::expr_binary(?op, ?a, ?b)) {
101101
auto av = eval_expr(cx, e, a);
102102
auto bv = eval_expr(cx, e, b);
103103
alt (op) {
@@ -214,7 +214,7 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
214214
&mutable vec[@ast::view_item] view_items,
215215
&mutable vec[@ast::item] items) {
216216
alt (x.node) {
217-
case (ast::expr_if(?cond, ?thn, ?elopt, _)) {
217+
case (ast::expr_if(?cond, ?thn, ?elopt)) {
218218
auto cv = eval_expr(cx, e, cond);
219219
if (!val_is_bool(cv)) {
220220
cx.sess.span_fatal(x.span, "bad cond type in 'if'");
@@ -234,7 +234,7 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
234234
}
235235
}
236236
}
237-
case (ast::expr_alt(?v, ?arms, _)) {
237+
case (ast::expr_alt(?v, ?arms)) {
238238
auto vv = eval_expr(cx, e, v);
239239
for (ast::arm arm in arms) {
240240
alt (arm.pat.node) {
@@ -259,7 +259,7 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
259259
}
260260
cx.sess.span_fatal(x.span, "no cases matched in 'alt'");
261261
}
262-
case (ast::expr_block(?block, _)) {
262+
case (ast::expr_block(?block)) {
263263
ret eval_crate_directive_block(cx, e, block, prefix, view_items,
264264
items);
265265
}

‎src/comp/front/extenv.rs

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
3232
// FIXME: duplicate code copied from extfmt:
3333
fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
3434
alt (expr.node) {
35-
case (ast::expr_lit(?l, _)) {
35+
case (ast::expr_lit(?l)) {
3636
alt (l.node) {
3737
case (ast::lit_str(?s, _)) { ret s; }
3838
case (_) { cx.span_fatal(l.span, "malformed #env call"); }
@@ -44,8 +44,7 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
4444

4545
fn make_new_lit(&ext_ctxt cx, common::span sp, ast::lit_ lit) -> @ast::expr {
4646
auto sp_lit = @rec(node=lit, span=sp);
47-
auto expr = ast::expr_lit(sp_lit, cx.next_id());
48-
ret @rec(node=expr, span=sp);
47+
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_lit), span=sp);
4948
}
5049

5150
fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {

‎src/comp/front/extfmt.rs

Lines changed: 12 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
3535
fn expr_to_str(&ext_ctxt cx, @ast::expr expr) -> str {
3636
auto err_msg = "first argument to #fmt must be a string literal";
3737
alt (expr.node) {
38-
case (ast::expr_lit(?l, _)) {
38+
case (ast::expr_lit(?l)) {
3939
alt (l.node) {
4040
case (ast::lit_str(?s, _)) { ret s; }
4141
case (_) { cx.span_fatal(l.span, err_msg); }
@@ -54,8 +54,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
5454
fn make_new_lit(&ext_ctxt cx, common::span sp, ast::lit_ lit) ->
5555
@ast::expr {
5656
auto sp_lit = @rec(node=lit, span=sp);
57-
auto expr = ast::expr_lit(sp_lit, cx.next_id());
58-
ret @rec(node=expr, span=sp);
57+
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_lit), span=sp);
5958
}
6059
fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {
6160
auto lit = ast::lit_str(s, ast::sk_rc);
@@ -71,31 +70,27 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
7170
}
7271
fn make_add_expr(&ext_ctxt cx, common::span sp, @ast::expr lhs,
7372
@ast::expr rhs) -> @ast::expr {
74-
auto binexpr = ast::expr_binary(ast::add, lhs, rhs, cx.next_id());
75-
ret @rec(node=binexpr, span=sp);
73+
auto binexpr = ast::expr_binary(ast::add, lhs, rhs);
74+
ret @rec(id=cx.next_id(), node=binexpr, span=sp);
7675
}
7776
fn make_path_expr(&ext_ctxt cx, common::span sp, vec[ast::ident] idents)
7877
-> @ast::expr {
7978
let vec[@ast::ty] types = [];
8079
auto path = rec(idents=idents, types=types);
8180
auto sp_path = rec(node=path, span=sp);
82-
auto pathexpr = ast::expr_path(sp_path, cx.next_id());
83-
auto sp_pathexpr = @rec(node=pathexpr, span=sp);
84-
ret sp_pathexpr;
81+
auto pathexpr = ast::expr_path(sp_path);
82+
ret @rec(id=cx.next_id(), node=pathexpr, span=sp);
8583
}
8684
fn make_vec_expr(&ext_ctxt cx, common::span sp, vec[@ast::expr] exprs) ->
8785
@ast::expr {
88-
auto vecexpr =
89-
ast::expr_vec(exprs, ast::imm, ast::sk_rc, cx.next_id());
90-
auto sp_vecexpr = @rec(node=vecexpr, span=sp);
91-
ret sp_vecexpr;
86+
auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc);
87+
ret @rec(id=cx.next_id(), node=vecexpr, span=sp);
9288
}
9389
fn make_call(&ext_ctxt cx, common::span sp, vec[ast::ident] fn_path,
9490
vec[@ast::expr] args) -> @ast::expr {
9591
auto pathexpr = make_path_expr(cx, sp, fn_path);
96-
auto callexpr = ast::expr_call(pathexpr, args, cx.next_id());
97-
auto sp_callexpr = @rec(node=callexpr, span=sp);
98-
ret sp_callexpr;
92+
auto callexpr = ast::expr_call(pathexpr, args);
93+
ret @rec(id=cx.next_id(), node=callexpr, span=sp);
9994
}
10095
fn make_rec_expr(&ext_ctxt cx, common::span sp,
10196
vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
@@ -107,10 +102,8 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
107102
rec(node=rec(mut=ast::imm, ident=ident, expr=val), span=sp);
108103
astfields += [astfield];
109104
}
110-
auto recexpr =
111-
ast::expr_rec(astfields, option::none[@ast::expr], cx.next_id());
112-
auto sp_recexpr = @rec(node=recexpr, span=sp);
113-
ret sp_recexpr;
105+
auto recexpr = ast::expr_rec(astfields, option::none[@ast::expr]);
106+
ret @rec(id=cx.next_id(), node=recexpr, span=sp);
114107
}
115108
fn make_path_vec(str ident) -> vec[str] {
116109
// FIXME: #fmt can't currently be used from within std

0 commit comments

Comments
 (0)