Skip to content

Commit ac8701c

Browse files
pcwaltonpcwalton
committed
---
yaml --- r: 2045 b: refs/heads/master c: 5355811 h: refs/heads/master i: 2043: 16dc365 v: v3
1 parent 377e7ea commit ac8701c

File tree

2 files changed

+84
-37
lines changed

2 files changed

+84
-37
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: ad7aff8203c5ad1d5a287e3205e8e6bbd6695fb3
2+
refs/heads/master: 535581185921ebb2602d4f42604e54436052fc1f

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

Lines changed: 83 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -288,6 +288,9 @@ type ast_fold[ENV] =
288288

289289
(fn(&ENV e, &span sp, ident i) -> @view_item) fold_view_item_export,
290290

291+
// Annotation folds.
292+
(fn(&ENV e, ann a) -> ann) fold_ann,
293+
291294
// Additional nodes.
292295
(fn(&ENV e, &span sp,
293296
&ast.block_) -> block) fold_block,
@@ -536,15 +539,17 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
536539
alt (e.node) {
537540
case (ast.expr_vec(?es, ?mut, ?t)) {
538541
auto ees = fold_exprs(env_, fld, es);
539-
ret fld.fold_expr_vec(env_, e.span, ees, mut, t);
542+
auto t2 = fld.fold_ann(env_, t);
543+
ret fld.fold_expr_vec(env_, e.span, ees, mut, t2);
540544
}
541545

542546
case (ast.expr_tup(?es, ?t)) {
543547
let vec[ast.elt] elts = vec();
544548
for (ast.elt e in es) {
545549
elts += vec(fold_tup_elt[ENV](env, fld, e));
546550
}
547-
ret fld.fold_expr_tup(env_, e.span, elts, t);
551+
auto t2 = fld.fold_ann(env_, t);
552+
ret fld.fold_expr_tup(env_, e.span, elts, t2);
548553
}
549554

550555
case (ast.expr_rec(?fs, ?base, ?t)) {
@@ -559,17 +564,20 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
559564
b = some[@expr](fold_expr(env_, fld, eb));
560565
}
561566
}
562-
ret fld.fold_expr_rec(env_, e.span, fields, b, t);
567+
auto t2 = fld.fold_ann(env_, t);
568+
ret fld.fold_expr_rec(env_, e.span, fields, b, t2);
563569
}
564570

565571
case (ast.expr_call(?f, ?args, ?t)) {
566572
auto ff = fold_expr(env_, fld, f);
567573
auto aargs = fold_exprs(env_, fld, args);
568-
ret fld.fold_expr_call(env_, e.span, ff, aargs, t);
574+
auto t2 = fld.fold_ann(env_, t);
575+
ret fld.fold_expr_call(env_, e.span, ff, aargs, t2);
569576
}
570577

571578
case (ast.expr_self_method(?ident, ?t)) {
572-
ret fld.fold_expr_self_method(env_, e.span, ident, t);
579+
auto t2 = fld.fold_ann(env_, t);
580+
ret fld.fold_expr_self_method(env_, e.span, ident, t2);
573581
}
574582

575583
case (ast.expr_bind(?f, ?args_opt, ?t)) {
@@ -586,34 +594,40 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
586594
case (none[@ast.expr]) { /* empty */ }
587595
}
588596
}
589-
ret fld.fold_expr_bind(env_, e.span, ff, aargs_opt, t);
597+
auto t2 = fld.fold_ann(env_, t);
598+
ret fld.fold_expr_bind(env_, e.span, ff, aargs_opt, t2);
590599
}
591600

592601
case (ast.expr_spawn(?dom, ?name, ?f, ?args, ?t)) {
593602
auto ff = fold_expr(env_, fld, f);
594603
auto aargs = fold_exprs(env_, fld, args);
595-
ret fld.fold_expr_spawn(env_, e.span, dom, name, ff, aargs, t);
604+
auto t2 = fld.fold_ann(env_, t);
605+
ret fld.fold_expr_spawn(env_, e.span, dom, name, ff, aargs, t2);
596606
}
597607

598608
case (ast.expr_binary(?op, ?a, ?b, ?t)) {
599609
auto aa = fold_expr(env_, fld, a);
600610
auto bb = fold_expr(env_, fld, b);
601-
ret fld.fold_expr_binary(env_, e.span, op, aa, bb, t);
611+
auto t2 = fld.fold_ann(env_, t);
612+
ret fld.fold_expr_binary(env_, e.span, op, aa, bb, t2);
602613
}
603614

604615
case (ast.expr_unary(?op, ?a, ?t)) {
605616
auto aa = fold_expr(env_, fld, a);
606-
ret fld.fold_expr_unary(env_, e.span, op, aa, t);
617+
auto t2 = fld.fold_ann(env_, t);
618+
ret fld.fold_expr_unary(env_, e.span, op, aa, t2);
607619
}
608620

609621
case (ast.expr_lit(?lit, ?t)) {
610-
ret fld.fold_expr_lit(env_, e.span, lit, t);
622+
auto t2 = fld.fold_ann(env_, t);
623+
ret fld.fold_expr_lit(env_, e.span, lit, t2);
611624
}
612625

613626
case (ast.expr_cast(?e, ?t, ?at)) {
614627
auto ee = fold_expr(env_, fld, e);
615628
auto tt = fold_ty(env, fld, t);
616-
ret fld.fold_expr_cast(env_, e.span, ee, tt, at);
629+
auto at2 = fld.fold_ann(env_, at);
630+
ret fld.fold_expr_cast(env_, e.span, ee, tt, at2);
617631
}
618632

619633
case (ast.expr_if(?cnd, ?thn, ?els, ?t)) {
@@ -626,33 +640,38 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
626640
}
627641
case (_) { /* fall through */ }
628642
}
629-
ret fld.fold_expr_if(env_, e.span, ccnd, tthn, eels, t);
643+
auto t2 = fld.fold_ann(env_, t);
644+
ret fld.fold_expr_if(env_, e.span, ccnd, tthn, eels, t2);
630645
}
631646

632647
case (ast.expr_for(?decl, ?seq, ?body, ?t)) {
633648
auto ddecl = fold_decl(env_, fld, decl);
634649
auto sseq = fold_expr(env_, fld, seq);
635650
auto bbody = fold_block(env_, fld, body);
636-
ret fld.fold_expr_for(env_, e.span, ddecl, sseq, bbody, t);
651+
auto t2 = fld.fold_ann(env_, t);
652+
ret fld.fold_expr_for(env_, e.span, ddecl, sseq, bbody, t2);
637653
}
638654

639655
case (ast.expr_for_each(?decl, ?seq, ?body, ?t)) {
640656
auto ddecl = fold_decl(env_, fld, decl);
641657
auto sseq = fold_expr(env_, fld, seq);
642658
auto bbody = fold_block(env_, fld, body);
643-
ret fld.fold_expr_for_each(env_, e.span, ddecl, sseq, bbody, t);
659+
auto t2 = fld.fold_ann(env_, t);
660+
ret fld.fold_expr_for_each(env_, e.span, ddecl, sseq, bbody, t2);
644661
}
645662

646663
case (ast.expr_while(?cnd, ?body, ?t)) {
647664
auto ccnd = fold_expr(env_, fld, cnd);
648665
auto bbody = fold_block(env_, fld, body);
649-
ret fld.fold_expr_while(env_, e.span, ccnd, bbody, t);
666+
auto t2 = fld.fold_ann(env_, t);
667+
ret fld.fold_expr_while(env_, e.span, ccnd, bbody, t2);
650668
}
651669

652670
case (ast.expr_do_while(?body, ?cnd, ?t)) {
653671
auto bbody = fold_block(env_, fld, body);
654672
auto ccnd = fold_expr(env_, fld, cnd);
655-
ret fld.fold_expr_do_while(env_, e.span, bbody, ccnd, t);
673+
auto t2 = fld.fold_ann(env_, t);
674+
ret fld.fold_expr_do_while(env_, e.span, bbody, ccnd, t2);
656675
}
657676

658677
case (ast.expr_alt(?expr, ?arms, ?t)) {
@@ -661,72 +680,85 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
661680
for (ast.arm a in arms) {
662681
aarms += vec(fold_arm(env_, fld, a));
663682
}
664-
ret fld.fold_expr_alt(env_, e.span, eexpr, aarms, t);
683+
auto t2 = fld.fold_ann(env_, t);
684+
ret fld.fold_expr_alt(env_, e.span, eexpr, aarms, t2);
665685
}
666686

667687
case (ast.expr_block(?b, ?t)) {
668688
auto bb = fold_block(env_, fld, b);
669-
ret fld.fold_expr_block(env_, e.span, bb, t);
689+
auto t2 = fld.fold_ann(env_, t);
690+
ret fld.fold_expr_block(env_, e.span, bb, t2);
670691
}
671692

672693
case (ast.expr_assign(?lhs, ?rhs, ?t)) {
673694
auto llhs = fold_expr(env_, fld, lhs);
674695
auto rrhs = fold_expr(env_, fld, rhs);
675-
ret fld.fold_expr_assign(env_, e.span, llhs, rrhs, t);
696+
auto t2 = fld.fold_ann(env_, t);
697+
ret fld.fold_expr_assign(env_, e.span, llhs, rrhs, t2);
676698
}
677699

678700
case (ast.expr_assign_op(?op, ?lhs, ?rhs, ?t)) {
679701
auto llhs = fold_expr(env_, fld, lhs);
680702
auto rrhs = fold_expr(env_, fld, rhs);
681-
ret fld.fold_expr_assign_op(env_, e.span, op, llhs, rrhs, t);
703+
auto t2 = fld.fold_ann(env_, t);
704+
ret fld.fold_expr_assign_op(env_, e.span, op, llhs, rrhs, t2);
682705
}
683706

684707
case (ast.expr_send(?lhs, ?rhs, ?t)) {
685708
auto llhs = fold_expr(env_, fld, lhs);
686709
auto rrhs = fold_expr(env_, fld, rhs);
687-
ret fld.fold_expr_send(env_, e.span, llhs, rrhs, t);
710+
auto t2 = fld.fold_ann(env_, t);
711+
ret fld.fold_expr_send(env_, e.span, llhs, rrhs, t2);
688712
}
689713

690714
case (ast.expr_recv(?lhs, ?rhs, ?t)) {
691715
auto llhs = fold_expr(env_, fld, lhs);
692716
auto rrhs = fold_expr(env_, fld, rhs);
693-
ret fld.fold_expr_recv(env_, e.span, llhs, rrhs, t);
717+
auto t2 = fld.fold_ann(env_, t);
718+
ret fld.fold_expr_recv(env_, e.span, llhs, rrhs, t2);
694719
}
695720

696721
case (ast.expr_field(?e, ?i, ?t)) {
697722
auto ee = fold_expr(env_, fld, e);
698-
ret fld.fold_expr_field(env_, e.span, ee, i, t);
723+
auto t2 = fld.fold_ann(env_, t);
724+
ret fld.fold_expr_field(env_, e.span, ee, i, t2);
699725
}
700726

701727
case (ast.expr_index(?e, ?ix, ?t)) {
702728
auto ee = fold_expr(env_, fld, e);
703729
auto iix = fold_expr(env_, fld, ix);
704-
ret fld.fold_expr_index(env_, e.span, ee, iix, t);
730+
auto t2 = fld.fold_ann(env_, t);
731+
ret fld.fold_expr_index(env_, e.span, ee, iix, t2);
705732
}
706733

707734
case (ast.expr_path(?p, ?r, ?t)) {
708735
auto p_ = fold_path(env_, fld, p);
709-
ret fld.fold_expr_path(env_, e.span, p_, r, t);
736+
auto t2 = fld.fold_ann(env_, t);
737+
ret fld.fold_expr_path(env_, e.span, p_, r, t2);
710738
}
711739

712740
case (ast.expr_ext(?p, ?args, ?body, ?expanded, ?t)) {
713741
// Only fold the expanded expression, not the
714742
// expressions involved in syntax extension
715743
auto exp = fold_expr(env_, fld, expanded);
744+
auto t2 = fld.fold_ann(env_, t);
716745
ret fld.fold_expr_ext(env_, e.span, p, args, body,
717-
exp, t);
746+
exp, t2);
718747
}
719748

720749
case (ast.expr_fail(?t)) {
721-
ret fld.fold_expr_fail(env_, e.span, t);
750+
auto t2 = fld.fold_ann(env_, t);
751+
ret fld.fold_expr_fail(env_, e.span, t2);
722752
}
723753

724754
case (ast.expr_break(?t)) {
725-
ret fld.fold_expr_break(env_, e.span, t);
755+
auto t2 = fld.fold_ann(env_, t);
756+
ret fld.fold_expr_break(env_, e.span, t2);
726757
}
727758

728759
case (ast.expr_cont(?t)) {
729-
ret fld.fold_expr_cont(env_, e.span, t);
760+
auto t2 = fld.fold_ann(env_, t);
761+
ret fld.fold_expr_cont(env_, e.span, t2);
730762
}
731763

732764
case (ast.expr_ret(?oe, ?t)) {
@@ -737,7 +769,8 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
737769
}
738770
case (_) { /* fall through */ }
739771
}
740-
ret fld.fold_expr_ret(env_, e.span, oee, t);
772+
auto t2 = fld.fold_ann(env_, t);
773+
ret fld.fold_expr_ret(env_, e.span, oee, t2);
741774
}
742775

743776
case (ast.expr_put(?oe, ?t)) {
@@ -748,31 +781,37 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
748781
}
749782
case (_) { /* fall through */ }
750783
}
751-
ret fld.fold_expr_put(env_, e.span, oee, t);
784+
auto t2 = fld.fold_ann(env_, t);
785+
ret fld.fold_expr_put(env_, e.span, oee, t2);
752786
}
753787

754788
case (ast.expr_be(?x, ?t)) {
755789
auto ee = fold_expr(env_, fld, x);
756-
ret fld.fold_expr_be(env_, e.span, ee, t);
790+
auto t2 = fld.fold_ann(env_, t);
791+
ret fld.fold_expr_be(env_, e.span, ee, t2);
757792
}
758793

759794
case (ast.expr_log(?x, ?t)) {
760795
auto ee = fold_expr(env_, fld, x);
761-
ret fld.fold_expr_log(env_, e.span, ee, t);
796+
auto t2 = fld.fold_ann(env_, t);
797+
ret fld.fold_expr_log(env_, e.span, ee, t2);
762798
}
763799

764800
case (ast.expr_check_expr(?x, ?t)) {
765801
auto ee = fold_expr(env_, fld, x);
766-
ret fld.fold_expr_check_expr(env_, e.span, ee, t);
802+
auto t2 = fld.fold_ann(env_, t);
803+
ret fld.fold_expr_check_expr(env_, e.span, ee, t2);
767804
}
768805

769806
case (ast.expr_port(?t)) {
770-
ret fld.fold_expr_port(env_, e.span, t);
807+
auto t2 = fld.fold_ann(env_, t);
808+
ret fld.fold_expr_port(env_, e.span, t2);
771809
}
772810

773811
case (ast.expr_chan(?x, ?t)) {
774812
auto ee = fold_expr(env_, fld, x);
775-
ret fld.fold_expr_chan(env_, e.span, ee, t);
813+
auto t2 = fld.fold_ann(env_, t);
814+
ret fld.fold_expr_chan(env_, e.span, ee, t2);
776815
}
777816
}
778817

@@ -1475,6 +1514,12 @@ fn identity_fold_view_item_export[ENV](&ENV e, &span sp, ident i)
14751514
ret @respan(sp, ast.view_item_export(i));
14761515
}
14771516

1517+
// Annotation folding.
1518+
1519+
fn identity_fold_ann[ENV](&ENV e, ann a) -> ann {
1520+
ret a;
1521+
}
1522+
14781523
// Additional identities.
14791524

14801525
fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block {
@@ -1668,6 +1713,8 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
16681713
fold_view_item_export =
16691714
bind identity_fold_view_item_export[ENV](_,_,_),
16701715

1716+
fold_ann = bind identity_fold_ann[ENV](_,_),
1717+
16711718
fold_block = bind identity_fold_block[ENV](_,_,_),
16721719
fold_fn = bind identity_fold_fn[ENV](_,_,_,_),
16731720
fold_fn_decl = bind identity_fold_fn_decl[ENV](_,_,_,_),

0 commit comments

Comments
 (0)