rustc: Use an extensible annotation field instead of putting option[@ty] everywhere

4 files changed, 94 insertions, 89 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 32317812f8f..e635c1191b3 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -15,6 +15,12 @@ type crate_num = int;
 type def_num = int;
 type def_id = tup(crate_num, def_num);
 
+// Annotations added during successive passes.
+tag ann {
+    ann_none;
+    ann_type(@ty);
+}
+
 tag def {
     def_fn(def_id);
     def_mod(def_id);
@@ -85,22 +91,22 @@ tag decl_ {
 
 type expr = spanned[expr_];
 tag expr_ {
-    expr_vec(vec[@expr], option[@ty]);
-    expr_tup(vec[tup(bool /* mutability */, @expr)], option[@ty]);
-    expr_rec(vec[tup(ident,@expr)], option[@ty]);
-    expr_call(@expr, vec[@expr], option[@ty]);
-    expr_binary(binop, @expr, @expr, option[@ty]);
-    expr_unary(unop, @expr, option[@ty]);
-    expr_lit(@lit, option[@ty]);
-    expr_cast(@expr, @ty);
-    expr_if(@expr, block, option[block], option[@ty]);
-    expr_while(@expr, block, option[@ty]);
-    expr_do_while(block, @expr, option[@ty]);
-    expr_block(block, option[@ty]);
-    expr_assign(@expr /* TODO: @expr|is_lval */, @expr, option[@ty]);
-    expr_field(@expr, ident, option[@ty]);
-    expr_index(@expr, @expr, option[@ty]);
-    expr_name(name, option[def], option[@ty]);
+    expr_vec(vec[@expr], ann);
+    expr_tup(vec[tup(bool /* mutability */, @expr)], ann);
+    expr_rec(vec[tup(ident,@expr)], ann);
+    expr_call(@expr, vec[@expr], ann);
+    expr_binary(binop, @expr, @expr, ann);
+    expr_unary(unop, @expr, ann);
+    expr_lit(@lit, ann);
+    expr_cast(@expr, @ty, ann);
+    expr_if(@expr, block, option[block], ann);
+    expr_while(@expr, block, ann);
+    expr_do_while(block, @expr, ann);
+    expr_block(block, ann);
+    expr_assign(@expr /* TODO: @expr|is_lval */, @expr, ann);
+    expr_field(@expr, ident, ann);
+    expr_index(@expr, @expr, ann);
+    expr_name(name, option[def], ann);
 }
 
 type lit = spanned[lit_];
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index 7046f4b0da1..97742a1853b 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -260,14 +260,14 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
     // FIXME: can only remove this sort of thing when both typestate and
     // alt-exhaustive-match checking are co-operating.
     auto lit = @spanned(lo, lo, ast.lit_nil);
-    let ast.expr_ ex = ast.expr_lit(lit, none[@ast.ty]);
+    let ast.expr_ ex = ast.expr_lit(lit, ast.ann_none);
 
     alt (p.peek()) {
 
         case (token.IDENT(?i)) {
             auto n = parse_name(p, i);
             hi = n.span;
-            ex = ast.expr_name(n, none[ast.def], none[@ast.ty]);
+            ex = ast.expr_name(n, none[ast.def], ast.ann_none);
             alt (p.peek()) {
                 case (token.LPAREN) {
                     // Call expr.
@@ -277,7 +277,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
                                                    some(token.COMMA),
                                                    pf, p);
                     ex = ast.expr_call(@spanned(lo, hi, ex),
-                                       es.node, none[@ast.ty]);
+                                       es.node, ast.ann_none);
                     hi = es.span;
                 }
             }
@@ -299,7 +299,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
                                                       some(token.COMMA),
                                                       pf, p);
             hi = es.span;
-            ex = ast.expr_tup(es.node, none[@ast.ty]);
+            ex = ast.expr_tup(es.node, ast.ann_none);
         }
 
         case (token.VEC) {
@@ -310,7 +310,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
                                            some(token.COMMA),
                                            pf, p);
             hi = es.span;
-            ex = ast.expr_vec(es.node, none[@ast.ty]);
+            ex = ast.expr_vec(es.node, ast.ann_none);
         }
 
         case (token.REC) {
@@ -329,14 +329,14 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
                                                      some(token.COMMA),
                                                      pf, p);
             hi = es.span;
-            ex = ast.expr_rec(es.node, none[@ast.ty]);
+            ex = ast.expr_rec(es.node, ast.ann_none);
         }
 
         case (_) {
             alt (parse_lit(p)) {
                 case (some[ast.lit](?lit)) {
                     hi = lit.span;
-                    ex = ast.expr_lit(@lit, none[@ast.ty]);
+                    ex = ast.expr_lit(@lit, ast.ann_none);
                 }
                 case (none[ast.lit]) {
                     p.err("expecting expression");
@@ -361,14 +361,14 @@ impure fn parse_path_expr(parser p) -> @ast.expr {
                     case (token.IDENT(?i)) {
                         hi = p.get_span();
                         p.bump();
-                        auto e_ = ast.expr_field(e, i, none[@ast.ty]);
+                        auto e_ = ast.expr_field(e, i, ast.ann_none);
                         e = @spanned(lo, hi, e_);
                     }
 
                     case (token.LPAREN) {
                         auto ix = parse_bottom_expr(p);
                         hi = ix.span;
-                        auto e_ = ast.expr_index(e, ix, none[@ast.ty]);
+                        auto e_ = ast.expr_index(e, ix, ast.ann_none);
                         e = @spanned(lo, hi, e_);
                     }
                 }
@@ -389,7 +389,7 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
     // FIXME: can only remove this sort of thing when both typestate and
     // alt-exhaustive-match checking are co-operating.
     auto lit = @spanned(lo, lo, ast.lit_nil);
-    let ast.expr_ ex = ast.expr_lit(lit, none[@ast.ty]);
+    let ast.expr_ ex = ast.expr_lit(lit, ast.ann_none);
 
     alt (p.peek()) {
 
@@ -397,14 +397,14 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
             p.bump();
             auto e = parse_prefix_expr(p);
             hi = e.span;
-            ex = ast.expr_unary(ast.not, e, none[@ast.ty]);
+            ex = ast.expr_unary(ast.not, e, ast.ann_none);
         }
 
         case (token.TILDE) {
             p.bump();
             auto e = parse_prefix_expr(p);
             hi = e.span;
-            ex = ast.expr_unary(ast.bitnot, e, none[@ast.ty]);
+            ex = ast.expr_unary(ast.bitnot, e, ast.ann_none);
         }
 
         case (token.BINOP(?b)) {
@@ -413,14 +413,14 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
                     p.bump();
                     auto e = parse_prefix_expr(p);
                     hi = e.span;
-                    ex = ast.expr_unary(ast.neg, e, none[@ast.ty]);
+                    ex = ast.expr_unary(ast.neg, e, ast.ann_none);
                 }
 
                 case (token.STAR) {
                     p.bump();
                     auto e = parse_prefix_expr(p);
                     hi = e.span;
-                    ex = ast.expr_unary(ast.deref, e, none[@ast.ty]);
+                    ex = ast.expr_unary(ast.deref, e, ast.ann_none);
                 }
 
                 case (_) {
@@ -433,7 +433,7 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
             p.bump();
             auto e = parse_prefix_expr(p);
             hi = e.span;
-            ex = ast.expr_unary(ast.box, e, none[@ast.ty]);
+            ex = ast.expr_unary(ast.box, e, ast.ann_none);
         }
 
         case (_) {
@@ -461,7 +461,7 @@ impure fn parse_binops(parser p,
                         auto rhs = sub(p);
                         hi = rhs.span;
                         auto exp = ast.expr_binary(pair._1, e, rhs,
-                                                   none[@ast.ty]);
+                                                   ast.ann_none);
                         e = @spanned(lo, hi, exp);
                         more = true;
                     }
@@ -487,7 +487,7 @@ impure fn parse_binary_exprs(parser p,
                 p.bump();
                 auto rhs = sub(p);
                 hi = rhs.span;
-                auto exp = ast.expr_binary(pair._1, e, rhs, none[@ast.ty]);
+                auto exp = ast.expr_binary(pair._1, e, rhs, ast.ann_none);
                 e = @spanned(lo, hi, exp);
                 more = true;
             }
@@ -541,7 +541,7 @@ impure fn parse_cast_expr(parser p) -> @ast.expr {
                 p.bump();
                 auto t = parse_ty(p);
                 hi = t.span;
-                e = @spanned(lo, hi, ast.expr_cast(e, t));
+                e = @spanned(lo, hi, ast.expr_cast(e, t, ast.ann_none));
             }
 
             case (_) {
@@ -585,7 +585,7 @@ impure fn parse_assign_expr(parser p) -> @ast.expr {
             p.bump();
             auto rhs = parse_expr(p);
             ret @spanned(lo, rhs.span,
-                         ast.expr_assign(lhs, rhs, none[@ast.ty]));
+                         ast.expr_assign(lhs, rhs, ast.ann_none));
         }
     }
     ret lhs;
@@ -610,7 +610,7 @@ impure fn parse_if_expr(parser p) -> @ast.expr {
             hi = eblk.span;
         }
     }
-    ret @spanned(lo, hi, ast.expr_if(cond, thn, els, none[@ast.ty]));
+    ret @spanned(lo, hi, ast.expr_if(cond, thn, els, ast.ann_none));
 }
 
 impure fn parse_while_expr(parser p) -> @ast.expr {
@@ -623,7 +623,7 @@ impure fn parse_while_expr(parser p) -> @ast.expr {
     expect(p, token.RPAREN);
     auto body = parse_block(p);
     hi = body.span;
-    ret @spanned(lo, hi, ast.expr_while(cond, body, none[@ast.ty]));
+    ret @spanned(lo, hi, ast.expr_while(cond, body, ast.ann_none));
 }
 
 impure fn parse_do_while_expr(parser p) -> @ast.expr {
@@ -637,7 +637,7 @@ impure fn parse_do_while_expr(parser p) -> @ast.expr {
     auto cond = parse_expr(p);
     expect(p, token.RPAREN);
     hi = cond.span;
-    ret @spanned(lo, hi, ast.expr_do_while(body, cond, none[@ast.ty]));
+    ret @spanned(lo, hi, ast.expr_do_while(body, cond, ast.ann_none));
 }
 
 impure fn parse_expr(parser p) -> @ast.expr {
@@ -645,7 +645,7 @@ impure fn parse_expr(parser p) -> @ast.expr {
         case (token.LBRACE) {
             auto blk = parse_block(p);
             ret @spanned(blk.span, blk.span,
-                         ast.expr_block(blk, none[@ast.ty]));
+                         ast.expr_block(blk, ast.ann_none));
         }
         case (token.IF) {
             ret parse_if_expr(p);
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index c5685680093..8b38c894c8c 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -22,6 +22,7 @@ import front.ast.arg;
 import front.ast.decl;
 import front.ast.def;
 import front.ast.def_id;
+import front.ast.ann;
 
 import std._vec;
 
@@ -50,64 +51,64 @@ type ast_fold[ENV] =
 
      // Expr folds.
      (fn(&ENV e, &span sp,
-         vec[@expr] es, option[@ty] ty) -> @expr) fold_expr_vec,
+         vec[@expr] es, ann a) -> @expr)          fold_expr_vec,
 
      (fn(&ENV e, &span sp,
          vec[tup(bool,@expr)] es,
-         option[@ty] ty) -> @expr)                fold_expr_tup,
+         ann a) -> @expr)                         fold_expr_tup,
 
      (fn(&ENV e, &span sp,
          vec[tup(ident,@expr)] fields,
-         option[@ty] ty) -> @expr)                fold_expr_rec,
+         ann a) -> @expr)                         fold_expr_rec,
 
      (fn(&ENV e, &span sp,
          @expr f, vec[@expr] args,
-         option[@ty] ty) -> @expr)                fold_expr_call,
+         ann a) -> @expr)                         fold_expr_call,
 
      (fn(&ENV e, &span sp,
          ast.binop,
          @expr lhs, @expr rhs,
-         option[@ty] ty) -> @expr)                fold_expr_binary,
+         ann a) -> @expr)                         fold_expr_binary,
 
      (fn(&ENV e, &span sp,
          ast.unop, @expr e,
-         option[@ty] ty) -> @expr)                fold_expr_unary,
+         ann a) -> @expr)                         fold_expr_unary,
 
      (fn(&ENV e, &span sp,
-         @ast.lit, option[@ty] ty) -> @expr)      fold_expr_lit,
+         @ast.lit, ann a) -> @expr)               fold_expr_lit,
 
      (fn(&ENV e, &span sp,
          @expr cond, &block thn,
          &option[block] els,
-         option[@ty] ty) -> @expr)                fold_expr_if,
+         ann a) -> @expr)                         fold_expr_if,
 
      (fn(&ENV e, &span sp,
          @expr cond, &block body,
-         option[@ty] ty) -> @expr)                fold_expr_while,
+         ann a) -> @expr)                         fold_expr_while,
 
      (fn(&ENV e, &span sp,
          &block body, @expr cond,
-         option[@ty] ty) -> @expr)                fold_expr_do_while,
+         ann a) -> @expr)                         fold_expr_do_while,
 
      (fn(&ENV e, &span sp,
-         &block blk, option[@ty] ty) -> @expr)    fold_expr_block,
+         &block blk, ann a) -> @expr)             fold_expr_block,
 
      (fn(&ENV e, &span sp,
          @expr lhs, @expr rhs,
-         option[@ty] ty) -> @expr)                fold_expr_assign,
+         ann a) -> @expr)                         fold_expr_assign,
 
      (fn(&ENV e, &span sp,
          @expr e, ident i,
-         option[@ty] ty) -> @expr)                fold_expr_field,
+         ann a) -> @expr)                         fold_expr_field,
 
      (fn(&ENV e, &span sp,
          @expr e, @expr ix,
-         option[@ty] ty) -> @expr)                fold_expr_index,
+         ann a) -> @expr)                         fold_expr_index,
 
      (fn(&ENV e, &span sp,
          &name n,
          &option[def] d,
-         option[@ty] ty) -> @expr)                fold_expr_name,
+         ann a) -> @expr)                         fold_expr_name,
 
      // Decl folds.
      (fn(&ENV e, &span sp,
@@ -575,86 +576,83 @@ fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p,
 // Expr identities.
 
 fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es,
-                               option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_vec(es, t));
+                               ann a) -> @expr {
+    ret @respan(sp, ast.expr_vec(es, a));
 }
 
 fn identity_fold_expr_tup[ENV](&ENV env, &span sp, vec[tup(bool, @expr)] es,
-                               option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_tup(es, t));
+                               ann a) -> @expr {
+    ret @respan(sp, ast.expr_tup(es, a));
 }
 
 fn identity_fold_expr_rec[ENV](&ENV env, &span sp,
-                               vec[tup(ident,@expr)] fields, option[@ty] t)
-    -> @expr {
-    ret @respan(sp, ast.expr_rec(fields, t));
+                               vec[tup(ident,@expr)] fields, ann a) -> @expr {
+    ret @respan(sp, ast.expr_rec(fields, a));
 }
 
 fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f,
-                                vec[@expr] args, option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_call(f, args, t));
+                                vec[@expr] args, ann a) -> @expr {
+    ret @respan(sp, ast.expr_call(f, args, a));
 }
 
 fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b,
                                   @expr lhs, @expr rhs,
-                                  option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_binary(b, lhs, rhs, t));
+                                  ann a) -> @expr {
+    ret @respan(sp, ast.expr_binary(b, lhs, rhs, a));
 }
 
 fn identity_fold_expr_unary[ENV](&ENV env, &span sp,
-                                 ast.unop u, @expr e, option[@ty] t)
+                                 ast.unop u, @expr e, ann a)
         -> @expr {
-    ret @respan(sp, ast.expr_unary(u, e, t));
+    ret @respan(sp, ast.expr_unary(u, e, a));
 }
 
 fn identity_fold_expr_lit[ENV](&ENV env, &span sp, @ast.lit lit,
-                               option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_lit(lit, t));
+                               ann a) -> @expr {
+    ret @respan(sp, ast.expr_lit(lit, a));
 }
 
 fn identity_fold_expr_if[ENV](&ENV env, &span sp,
                               @expr cond, &block thn,
-                              &option[block] els, option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_if(cond, thn, els, t));
+                              &option[block] els, ann a) -> @expr {
+    ret @respan(sp, ast.expr_if(cond, thn, els, a));
 }
 
 fn identity_fold_expr_while[ENV](&ENV env, &span sp,
-                                 @expr cond, &block body,
-                                 option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_while(cond, body, t));
+                                 @expr cond, &block body, ann a) -> @expr {
+    ret @respan(sp, ast.expr_while(cond, body, a));
 }
 
 fn identity_fold_expr_do_while[ENV](&ENV env, &span sp,
-                                    &block body, @expr cond,
-                                    option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_do_while(body, cond, t));
+                                    &block body, @expr cond, ann a) -> @expr {
+    ret @respan(sp, ast.expr_do_while(body, cond, a));
 }
 
 fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk,
-                                 option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_block(blk, t));
+                                 ann a) -> @expr {
+    ret @respan(sp, ast.expr_block(blk, a));
 }
 
 fn identity_fold_expr_assign[ENV](&ENV env, &span sp,
-                                  @expr lhs, @expr rhs, option[@ty] t)
+                                  @expr lhs, @expr rhs, ann a)
         -> @expr {
-    ret @respan(sp, ast.expr_assign(lhs, rhs, t));
+    ret @respan(sp, ast.expr_assign(lhs, rhs, a));
 }
 
 fn identity_fold_expr_field[ENV](&ENV env, &span sp,
-                                 @expr e, ident i, option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_field(e, i, t));
+                                 @expr e, ident i, ann a) -> @expr {
+    ret @respan(sp, ast.expr_field(e, i, a));
 }
 
 fn identity_fold_expr_index[ENV](&ENV env, &span sp,
-                                 @expr e, @expr ix, option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_index(e, ix, t));
+                                 @expr e, @expr ix, ann a) -> @expr {
+    ret @respan(sp, ast.expr_index(e, ix, a));
 }
 
 fn identity_fold_expr_name[ENV](&ENV env, &span sp,
                                 &name n, &option[def] d,
-                                option[@ty] t) -> @expr {
-    ret @respan(sp, ast.expr_name(n, d, t));
+                                ann a) -> @expr {
+    ret @respan(sp, ast.expr_name(n, d, a));
 }
 
 
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 31aca9cc1bd..5741bac44d6 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -1,6 +1,7 @@
 import front.ast;
 import front.ast.ident;
 import front.ast.def;
+import front.ast.ann;
 import driver.session;
 import util.common.span;
 import std.map.hashmap;
@@ -102,7 +103,7 @@ fn lookup_name(&env e, ast.ident i) -> option[def] {
 }
 
 fn fold_expr_name(&env e, &span sp, &ast.name n,
-                  &option[def] d, option[@ast.ty] t) -> @ast.expr {
+                  &option[def] d, ann a) -> @ast.expr {
 
     auto d_ = lookup_name(e, n.node.ident);
 
@@ -115,7 +116,7 @@ fn fold_expr_name(&env e, &span sp, &ast.name n,
         }
     }
 
-    ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, t));
+    ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, a));
 }
 
 fn update_env_for_crate(&env e, @ast.crate c) -> env {