bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add a type slot to the AST

Browse source
This commit is contained in:
Patrick Walton 2010-10-19 13:28:43 -07:00
parent e497fe981b
commit 10d628dbd0
4 changed files with 98 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

41
src/comp/front/parser.rs
View file

@ -259,14 +259,15 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
// FIXME: can only remove this sort of thing when both typestate and // FIXME: can only remove this sort of thing when both typestate and
// alt-exhaustive-match checking are co-operating. // alt-exhaustive-match checking are co-operating.
let ast.expr_ ex = ast.expr_lit(@spanned(lo, lo, ast.lit_nil)); auto lit = @spanned(lo, lo, ast.lit_nil);
let ast.expr_ ex = ast.expr_lit(lit, none[@ast.ty]);
alt (p.peek()) { alt (p.peek()) {
case (token.IDENT(?i)) { case (token.IDENT(?i)) {
auto n = parse_name(p, i); auto n = parse_name(p, i);
hi = n.span; hi = n.span;
ex = ast.expr_name(n, none[ast.def]); ex = ast.expr_name(n, none[ast.def], none[@ast.ty]);
} }
case (token.LPAREN) { case (token.LPAREN) {
@ -285,7 +286,7 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
some(token.COMMA), some(token.COMMA),
pf, p); pf, p);
hi = es.span; hi = es.span;
ex = ast.expr_tup(es.node); ex = ast.expr_tup(es.node, none[@ast.ty]);
} }
case (token.VEC) { case (token.VEC) {
@ -296,7 +297,7 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
some(token.COMMA), some(token.COMMA),
pf, p); pf, p);
hi = es.span; hi = es.span;
ex = ast.expr_vec(es.node); ex = ast.expr_vec(es.node, none[@ast.ty]);
} }
case (token.REC) { case (token.REC) {
@ -315,14 +316,14 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
some(token.COMMA), some(token.COMMA),
pf, p); pf, p);
hi = es.span; hi = es.span;
ex = ast.expr_rec(es.node); ex = ast.expr_rec(es.node, none[@ast.ty]);
} }
case (_) { case (_) {
alt (parse_lit(p)) { alt (parse_lit(p)) {
case (some[ast.lit](?lit)) { case (some[ast.lit](?lit)) {
hi = lit.span; hi = lit.span;
ex = ast.expr_lit(@lit); ex = ast.expr_lit(@lit, none[@ast.ty]);
} }
case (none[ast.lit]) { case (none[ast.lit]) {
p.err("expecting expression"); p.err("expecting expression");
@ -347,13 +348,15 @@ io fn parse_path_expr(parser p) -> @ast.expr {
case (token.IDENT(?i)) { case (token.IDENT(?i)) {
hi = p.get_span(); hi = p.get_span();
p.bump(); p.bump();
e = @spanned(lo, hi, ast.expr_field(e, i)); auto e_ = ast.expr_field(e, i, none[@ast.ty]);
e = @spanned(lo, hi, e_);
} }
case (token.LPAREN) { case (token.LPAREN) {
auto ix = parse_bottom_expr(p); auto ix = parse_bottom_expr(p);
hi = ix.span; hi = ix.span;
e = @spanned(lo, hi, ast.expr_index(e, ix)); auto e_ = ast.expr_index(e, ix, none[@ast.ty]);
e = @spanned(lo, hi, e_);
} }
} }
} }
@ -372,7 +375,8 @@ io fn parse_prefix_expr(parser p) -> @ast.expr {
// FIXME: can only remove this sort of thing when both typestate and // FIXME: can only remove this sort of thing when both typestate and
// alt-exhaustive-match checking are co-operating. // alt-exhaustive-match checking are co-operating.
let ast.expr_ ex = ast.expr_lit(@spanned(lo, lo, ast.lit_nil)); auto lit = @spanned(lo, lo, ast.lit_nil);
let ast.expr_ ex = ast.expr_lit(lit, none[@ast.ty]);
alt (p.peek()) { alt (p.peek()) {
@ -380,14 +384,14 @@ io fn parse_prefix_expr(parser p) -> @ast.expr {
p.bump(); p.bump();
auto e = parse_prefix_expr(p); auto e = parse_prefix_expr(p);
hi = e.span; hi = e.span;
ex = ast.expr_unary(ast.not, e); ex = ast.expr_unary(ast.not, e, none[@ast.ty]);
} }
case (token.TILDE) { case (token.TILDE) {
p.bump(); p.bump();
auto e = parse_prefix_expr(p); auto e = parse_prefix_expr(p);
hi = e.span; hi = e.span;
ex = ast.expr_unary(ast.bitnot, e); ex = ast.expr_unary(ast.bitnot, e, none[@ast.ty]);
} }
case (token.BINOP(?b)) { case (token.BINOP(?b)) {
@ -396,14 +400,14 @@ io fn parse_prefix_expr(parser p) -> @ast.expr {
p.bump(); p.bump();
auto e = parse_prefix_expr(p); auto e = parse_prefix_expr(p);
hi = e.span; hi = e.span;
ex = ast.expr_unary(ast.neg, e); ex = ast.expr_unary(ast.neg, e, none[@ast.ty]);
} }
case (token.STAR) { case (token.STAR) {
p.bump(); p.bump();
auto e = parse_prefix_expr(p); auto e = parse_prefix_expr(p);
hi = e.span; hi = e.span;
ex = ast.expr_unary(ast.deref, e); ex = ast.expr_unary(ast.deref, e, none[@ast.ty]);
} }
case (_) { case (_) {
@ -416,7 +420,7 @@ io fn parse_prefix_expr(parser p) -> @ast.expr {
p.bump(); p.bump();
auto e = parse_prefix_expr(p); auto e = parse_prefix_expr(p);
hi = e.span; hi = e.span;
ex = ast.expr_unary(ast.box, e); ex = ast.expr_unary(ast.box, e, none[@ast.ty]);
} }
case (_) { case (_) {
@ -443,7 +447,8 @@ io fn parse_binops(parser p,
p.bump(); p.bump();
auto rhs = sub(p); auto rhs = sub(p);
hi = rhs.span; hi = rhs.span;
auto exp = ast.expr_binary(pair._1, e, rhs); auto exp = ast.expr_binary(pair._1, e, rhs,
none[@ast.ty]);
e = @spanned(lo, hi, exp); e = @spanned(lo, hi, exp);
more = true; more = true;
} }
@ -469,7 +474,7 @@ io fn parse_binary_exprs(parser p,
p.bump(); p.bump();
auto rhs = sub(p); auto rhs = sub(p);
hi = rhs.span; hi = rhs.span;
auto exp = ast.expr_binary(pair._1, e, rhs); auto exp = ast.expr_binary(pair._1, e, rhs, none[@ast.ty]);
e = @spanned(lo, hi, exp); e = @spanned(lo, hi, exp);
more = true; more = true;
} }
@ -578,7 +583,7 @@ io fn parse_if_expr(parser p) -> @ast.expr {
hi = eblk.span; hi = eblk.span;
} }
} }
ret @spanned(lo, hi, ast.expr_if(cond, thn, els)); ret @spanned(lo, hi, ast.expr_if(cond, thn, els, none[@ast.ty]));
} }
io fn parse_expr(parser p) -> @ast.expr { io fn parse_expr(parser p) -> @ast.expr {
@ -586,7 +591,7 @@ io fn parse_expr(parser p) -> @ast.expr {
case (token.LBRACE) { case (token.LBRACE) {
auto blk = parse_block(p); auto blk = parse_block(p);
ret @spanned(blk.span, blk.span, ret @spanned(blk.span, blk.span,
ast.expr_block(blk)); ast.expr_block(blk, none[@ast.ty]));
} }
case (token.IF) { case (token.IF) {
ret parse_if_expr(p); ret parse_if_expr(p);

132
src/comp/middle/fold.rs
View file

@ -106,7 +106,7 @@ type ast_fold[ENV] =
&ast.local local) -> @decl) fold_decl_local, &ast.local local) -> @decl) fold_decl_local,
(fn(&ENV e, &span sp, (fn(&ENV e, &span sp,
@item item, option[@ty] ty) -> @decl) fold_decl_item, @item item) -> @decl) fold_decl_item,
// Stmt folds. // Stmt folds.
@ -278,49 +278,49 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
} }
alt (e.node) { alt (e.node) {
case (ast.expr_vec(?es)) { case (ast.expr_vec(?es, ?t)) {
auto ees = fold_exprs(env_, fld, es); auto ees = fold_exprs(env_, fld, es);
ret fld.fold_expr_vec(env_, e.span, ees); ret fld.fold_expr_vec(env_, e.span, ees, t);
} }
case (ast.expr_tup(?es)) { case (ast.expr_tup(?es, ?t)) {
let vec[tup(bool,@expr)] entries = vec(); let vec[tup(bool,@expr)] entries = vec();
for (tup(bool,@expr) entry in es) { for (tup(bool,@expr) entry in es) {
entries += fold_tup_entry[ENV](env, fld, entry); entries += fold_tup_entry[ENV](env, fld, entry);
} }
ret fld.fold_expr_tup(env_, e.span, entries); ret fld.fold_expr_tup(env_, e.span, entries, t);
} }
case (ast.expr_rec(?es)) { case (ast.expr_rec(?es, ?t)) {
let vec[tup(ident,@expr)] entries = vec(); let vec[tup(ident,@expr)] entries = vec();
for (tup(ident,@expr) entry in es) { for (tup(ident,@expr) entry in es) {
entries += fold_rec_entry(env, fld, entry); entries += fold_rec_entry(env, fld, entry);
} }
ret fld.fold_expr_rec(env_, e.span, entries); ret fld.fold_expr_rec(env_, e.span, entries, t);
} }
case (ast.expr_call(?f, ?args)) { case (ast.expr_call(?f, ?args, ?t)) {
auto ff = fold_expr(env_, fld, f); auto ff = fold_expr(env_, fld, f);
auto aargs = fold_exprs(env_, fld, args); auto aargs = fold_exprs(env_, fld, args);
ret fld.fold_expr_call(env_, e.span, ff, aargs); ret fld.fold_expr_call(env_, e.span, ff, aargs, t);
} }
case (ast.expr_binary(?op, ?a, ?b)) { case (ast.expr_binary(?op, ?a, ?b, ?t)) {
auto aa = fold_expr(env_, fld, a); auto aa = fold_expr(env_, fld, a);
auto bb = fold_expr(env_, fld, b); auto bb = fold_expr(env_, fld, b);
ret fld.fold_expr_binary(env_, e.span, op, aa, bb); ret fld.fold_expr_binary(env_, e.span, op, aa, bb, t);
} }
case (ast.expr_unary(?op, ?a)) { case (ast.expr_unary(?op, ?a, ?t)) {
auto aa = fold_expr(env_, fld, a); auto aa = fold_expr(env_, fld, a);
ret fld.fold_expr_unary(env_, e.span, op, a); ret fld.fold_expr_unary(env_, e.span, op, a, t);
} }
case (ast.expr_lit(?lit)) { case (ast.expr_lit(?lit, ?t)) {
ret fld.fold_expr_lit(env_, e.span, lit); ret fld.fold_expr_lit(env_, e.span, lit, t);
} }
case (ast.expr_if(?cnd, ?thn, ?els)) { case (ast.expr_if(?cnd, ?thn, ?els, ?t)) {
auto ccnd = fold_expr(env_, fld, cnd); auto ccnd = fold_expr(env_, fld, cnd);
auto tthn = fold_block(env_, fld, thn); auto tthn = fold_block(env_, fld, thn);
auto eels = none[block]; auto eels = none[block];
@ -329,34 +329,34 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
eels = some(fold_block(env_, fld, b)); eels = some(fold_block(env_, fld, b));
} }
} }
ret fld.fold_expr_if(env_, e.span, ccnd, tthn, eels); ret fld.fold_expr_if(env_, e.span, ccnd, tthn, eels, t);
} }
case (ast.expr_block(?b)) { case (ast.expr_block(?b, ?t)) {
auto bb = fold_block(env_, fld, b); auto bb = fold_block(env_, fld, b);
ret fld.fold_expr_block(env_, e.span, bb); ret fld.fold_expr_block(env_, e.span, bb, t);
} }
case (ast.expr_assign(?lhs, ?rhs)) { case (ast.expr_assign(?lhs, ?rhs, ?t)) {
auto llhs = fold_expr(env_, fld, lhs); auto llhs = fold_expr(env_, fld, lhs);
auto rrhs = fold_expr(env_, fld, rhs); auto rrhs = fold_expr(env_, fld, rhs);
ret fld.fold_expr_assign(env_, e.span, llhs, rrhs); ret fld.fold_expr_assign(env_, e.span, llhs, rrhs, t);
} }
case (ast.expr_field(?e, ?i)) { case (ast.expr_field(?e, ?i, ?t)) {
auto ee = fold_expr(env_, fld, e); auto ee = fold_expr(env_, fld, e);
ret fld.fold_expr_field(env_, e.span, ee, i); ret fld.fold_expr_field(env_, e.span, ee, i, t);
} }
case (ast.expr_index(?e, ?ix)) { case (ast.expr_index(?e, ?ix, ?t)) {
auto ee = fold_expr(env_, fld, e); auto ee = fold_expr(env_, fld, e);
auto iix = fold_expr(env_, fld, ix); auto iix = fold_expr(env_, fld, ix);
ret fld.fold_expr_index(env_, e.span, ee, iix); ret fld.fold_expr_index(env_, e.span, ee, iix, t);
} }
case (ast.expr_name(?n, ?r)) { case (ast.expr_name(?n, ?r, ?t)) {
auto n_ = fold_name(env_, fld, n); auto n_ = fold_name(env_, fld, n);
ret fld.fold_expr_name(env_, e.span, n, r); ret fld.fold_expr_name(env_, e.span, n, r, t);
} }
} }
@ -547,74 +547,74 @@ fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p,
// Expr identities. // Expr identities.
fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es, fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_vec(es, ty)); ret @respan(sp, ast.expr_vec(es, t));
} }
fn identity_fold_expr_tup[ENV](&ENV env, &span sp, vec[tup(bool, @expr)] es, fn identity_fold_expr_tup[ENV](&ENV env, &span sp, vec[tup(bool, @expr)] es,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_tup(es, ty)); ret @respan(sp, ast.expr_tup(es, t));
} }
fn identity_fold_expr_rec[ENV](&ENV env, &span sp, fn identity_fold_expr_rec[ENV](&ENV env, &span sp,
vec[tup(ident,@expr)] fields, option[@ty] ty) vec[tup(ident,@expr)] fields, option[@ty] t)
-> @expr { -> @expr {
ret @respan(sp, ast.expr_rec(fields, ty)); ret @respan(sp, ast.expr_rec(fields, t));
} }
fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f, fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f,
vec[@expr] args, option[@ty] ty) -> @expr { vec[@expr] args, option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_call(f, args, ty)); ret @respan(sp, ast.expr_call(f, args, t));
} }
fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b, fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b,
@expr lhs, @expr rhs, @expr lhs, @expr rhs,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_binary(b, lhs, rhs, ty)); ret @respan(sp, ast.expr_binary(b, lhs, rhs, t));
} }
fn identity_fold_expr_unary[ENV](&ENV env, &span sp, fn identity_fold_expr_unary[ENV](&ENV env, &span sp,
ast.unop u, @expr e, option[@ty] ty) ast.unop u, @expr e, option[@ty] t)
-> @expr { -> @expr {
ret @respan(sp, ast.expr_unary(u, e, ty)); ret @respan(sp, ast.expr_unary(u, e, t));
} }
fn identity_fold_expr_lit[ENV](&ENV env, &span sp, @ast.lit lit, fn identity_fold_expr_lit[ENV](&ENV env, &span sp, @ast.lit lit,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_lit(lit, ty)); ret @respan(sp, ast.expr_lit(lit, t));
} }
fn identity_fold_expr_if[ENV](&ENV env, &span sp, fn identity_fold_expr_if[ENV](&ENV env, &span sp,
@expr cond, &block thn, @expr cond, &block thn,
&option[block] els, option[@ty] ty) -> @expr { &option[block] els, option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_if(cond, thn, els, ty)); ret @respan(sp, ast.expr_if(cond, thn, els, t));
} }
fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk, fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_block(blk, ty)); ret @respan(sp, ast.expr_block(blk, t));
} }
fn identity_fold_expr_assign[ENV](&ENV env, &span sp, fn identity_fold_expr_assign[ENV](&ENV env, &span sp,
@expr lhs, @expr rhs, option[@ty] ty) @expr lhs, @expr rhs, option[@ty] t)
-> @expr { -> @expr {
ret @respan(sp, ast.expr_assign(lhs, rhs, ty)); ret @respan(sp, ast.expr_assign(lhs, rhs, t));
} }
fn identity_fold_expr_field[ENV](&ENV env, &span sp, fn identity_fold_expr_field[ENV](&ENV env, &span sp,
@expr e, ident i, option[@ty] ty) -> @expr { @expr e, ident i, option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_field(e, i, ty)); ret @respan(sp, ast.expr_field(e, i, t));
} }
fn identity_fold_expr_index[ENV](&ENV env, &span sp, fn identity_fold_expr_index[ENV](&ENV env, &span sp,
@expr e, @expr ix, option[@ty] ty) -> @expr { @expr e, @expr ix, option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_index(e, ix, ty)); ret @respan(sp, ast.expr_index(e, ix, t));
} }
fn identity_fold_expr_name[ENV](&ENV env, &span sp, fn identity_fold_expr_name[ENV](&ENV env, &span sp,
&name n, &option[def] d, &name n, &option[def] d,
option[@ty] ty) -> @expr { option[@ty] t) -> @expr {
ret @respan(sp, ast.expr_name(n, d, ty)); ret @respan(sp, ast.expr_name(n, d, t));
} }
@ -745,19 +745,19 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
fold_ty_tup = bind identity_fold_ty_tup[ENV](_,_,_), fold_ty_tup = bind identity_fold_ty_tup[ENV](_,_,_),
fold_ty_path = bind identity_fold_ty_path[ENV](_,_,_,_), fold_ty_path = bind identity_fold_ty_path[ENV](_,_,_,_),
fold_expr_vec = bind identity_fold_expr_vec[ENV](_,_,_), fold_expr_vec = bind identity_fold_expr_vec[ENV](_,_,_,_),
fold_expr_tup = bind identity_fold_expr_tup[ENV](_,_,_), fold_expr_tup = bind identity_fold_expr_tup[ENV](_,_,_,_),
fold_expr_rec = bind identity_fold_expr_rec[ENV](_,_,_), fold_expr_rec = bind identity_fold_expr_rec[ENV](_,_,_,_),
fold_expr_call = bind identity_fold_expr_call[ENV](_,_,_,_), fold_expr_call = bind identity_fold_expr_call[ENV](_,_,_,_,_),
fold_expr_binary = bind identity_fold_expr_binary[ENV](_,_,_,_,_), fold_expr_binary = bind identity_fold_expr_binary[ENV](_,_,_,_,_,_),
fold_expr_unary = bind identity_fold_expr_unary[ENV](_,_,_,_), fold_expr_unary = bind identity_fold_expr_unary[ENV](_,_,_,_,_),
fold_expr_lit = bind identity_fold_expr_lit[ENV](_,_,_), fold_expr_lit = bind identity_fold_expr_lit[ENV](_,_,_,_),
fold_expr_if = bind identity_fold_expr_if[ENV](_,_,_,_,_), fold_expr_if = bind identity_fold_expr_if[ENV](_,_,_,_,_,_),
fold_expr_block = bind identity_fold_expr_block[ENV](_,_,_), fold_expr_block = bind identity_fold_expr_block[ENV](_,_,_,_),
fold_expr_assign = bind identity_fold_expr_assign[ENV](_,_,_,_), fold_expr_assign = bind identity_fold_expr_assign[ENV](_,_,_,_,_),
fold_expr_field = bind identity_fold_expr_field[ENV](_,_,_,_), fold_expr_field = bind identity_fold_expr_field[ENV](_,_,_,_,_),
fold_expr_index = bind identity_fold_expr_index[ENV](_,_,_,_), fold_expr_index = bind identity_fold_expr_index[ENV](_,_,_,_,_),
fold_expr_name = bind identity_fold_expr_name[ENV](_,_,_,_), fold_expr_name = bind identity_fold_expr_name[ENV](_,_,_,_,_),
fold_decl_local = bind identity_fold_decl_local[ENV](_,_,_), fold_decl_local = bind identity_fold_decl_local[ENV](_,_,_),
fold_decl_item = bind identity_fold_decl_item[ENV](_,_,_), fold_decl_item = bind identity_fold_decl_item[ENV](_,_,_),

6
src/comp/middle/resolve.rs
View file

@ -101,7 +101,7 @@ fn lookup_name(&env e, ast.ident i) -> option[def] {
} }
fn fold_expr_name(&env e, &span sp, &ast.name n, fn fold_expr_name(&env e, &span sp, &ast.name n,
&option[def] d) -> @ast.expr { &option[def] d, option[@ast.ty] t) -> @ast.expr {
auto d_ = lookup_name(e, n.node.ident); auto d_ = lookup_name(e, n.node.ident);
@ -114,7 +114,7 @@ fn fold_expr_name(&env e, &span sp, &ast.name n,
} }
} }
ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_)); ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, t));
} }
fn update_env_for_crate(&env e, @ast.crate c) -> env { fn update_env_for_crate(&env e, @ast.crate c) -> env {
@ -131,7 +131,7 @@ fn update_env_for_block(&env e, &ast.block b) -> env {
fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate { fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate {
let fold.ast_fold[env] fld = fold.new_identity_fold[env](); let fold.ast_fold[env] fld = fold.new_identity_fold[env]();
fld = @rec( fold_expr_name = bind fold_expr_name(_,_,_,_), fld = @rec( fold_expr_name = bind fold_expr_name(_,_,_,_,_),
update_env_for_crate = bind update_env_for_crate(_,_), update_env_for_crate = bind update_env_for_crate(_,_),
update_env_for_item = bind update_env_for_item(_,_), update_env_for_item = bind update_env_for_item(_,_),
update_env_for_block = bind update_env_for_block(_,_) update_env_for_block = bind update_env_for_block(_,_)

12
src/comp/middle/trans.rs
View file

@ -546,23 +546,23 @@ fn trans_if(@block_ctxt cx, &ast.expr cond,
fn trans_expr(@block_ctxt cx, &ast.expr e) -> result { fn trans_expr(@block_ctxt cx, &ast.expr e) -> result {
alt (e.node) { alt (e.node) {
case (ast.expr_lit(?lit)) { case (ast.expr_lit(?lit, _)) {
ret trans_lit(cx, *lit); ret trans_lit(cx, *lit);
} }
case (ast.expr_unary(?op, ?x)) { case (ast.expr_unary(?op, ?x, _)) {
ret trans_unary(cx, op, *x); ret trans_unary(cx, op, *x);
} }
case (ast.expr_binary(?op, ?x, ?y)) { case (ast.expr_binary(?op, ?x, ?y, _)) {
ret trans_binary(cx, op, *x, *y); ret trans_binary(cx, op, *x, *y);
} }
case (ast.expr_if(?cond, ?thn, ?els)) { case (ast.expr_if(?cond, ?thn, ?els, _)) {
ret trans_if(cx, *cond, thn, els); ret trans_if(cx, *cond, thn, els);
} }
case (ast.expr_block(?blk)) { case (ast.expr_block(?blk, _)) {
auto sub_cx = new_empty_block_ctxt(cx.fcx); auto sub_cx = new_empty_block_ctxt(cx.fcx);
auto next_cx = new_extension_block_ctxt(cx); auto next_cx = new_extension_block_ctxt(cx);
auto sub = trans_block(sub_cx, blk); auto sub = trans_block(sub_cx, blk);
@ -579,7 +579,7 @@ fn trans_expr(@block_ctxt cx, &ast.expr e) -> result {
fn trans_log(@block_ctxt cx, &ast.expr e) -> result { fn trans_log(@block_ctxt cx, &ast.expr e) -> result {
alt (e.node) { alt (e.node) {
case (ast.expr_lit(?lit)) { case (ast.expr_lit(?lit, _)) {
alt (lit.node) { alt (lit.node) {
case (ast.lit_str(_)) { case (ast.lit_str(_)) {
auto sub = trans_expr(cx, e); auto sub = trans_expr(cx, e);