Get rid of arm indices

src/comp/front/ast.rs

@@ -233,7 +233,7 @@ tag decl_ {
     decl_item(@item);
 }
 
-type arm = rec(@pat pat, block block, hashmap[ident,def_id] index);
+type arm = rec(@pat pat, block block);
 
 type elt = rec(mutability mut, @expr expr);
 type field = rec(mutability mut, ident ident, @expr expr);

src/comp/front/parser.rs

@@ -1367,9 +1367,8 @@ fn parse_alt_expr(parser p) -> @ast.expr {
                 expect(p, token.LPAREN);
                 auto pat = parse_pat(p);
                 expect(p, token.RPAREN);
-                auto index = index_arm(pat);
                 auto block = parse_block(p);
-                arms += vec(rec(pat=pat, block=block, index=index));
+                arms += vec(rec(pat=pat, block=block));
             }
 
             // FIXME: this is a vestigial form left over from
@@ -1384,9 +1383,8 @@ fn parse_alt_expr(parser p) -> @ast.expr {
                 p.bump();
                 auto hi = p.get_hi_pos();
                 auto pat = @spanned(lo, hi, ast.pat_wild(p.get_ann()));
-                auto index = index_arm(pat);
                 auto block = parse_block(p);
-                arms += vec(rec(pat=pat, block=block, index=index));
+                arms += vec(rec(pat=pat, block=block));
             }
             case (token.RBRACE) { /* empty */ }
             case (?tok) {
@@ -1626,25 +1624,6 @@ fn parse_source_stmt(parser p) -> @ast.stmt {
     fail;
 }
 
-fn index_arm(@ast.pat pat) -> hashmap[ast.ident,ast.def_id] {
-    fn do_index_arm(&hashmap[ast.ident,ast.def_id] index, @ast.pat pat) {
-        alt (pat.node) {
-            case (ast.pat_bind(?i, ?def_id, _)) { index.insert(i, def_id); }
-            case (ast.pat_wild(_)) { /* empty */ }
-            case (ast.pat_lit(_, _)) { /* empty */ }
-            case (ast.pat_tag(_, ?pats, _, _)) {
-                for (@ast.pat p in pats) {
-                    do_index_arm(index, p);
-                }
-            }
-        }
-    }
-
-    auto index = new_str_hash[ast.def_id]();
-    do_index_arm(index, pat);
-    ret index;
-}
-
 fn stmt_to_expr(@ast.stmt stmt) -> Option.t[@ast.expr] {
     alt (stmt.node) {
         case (ast.stmt_expr(?e,_)) { ret some[@ast.expr](e); }

src/comp/middle/fold.rs

@@ -892,7 +892,7 @@ fn fold_arm[ENV](&ENV env, &ast_fold[ENV] fld, &arm a) -> arm {
     let ENV env_ = fld.update_env_for_arm(env, a);
     auto ppat = fold_pat(env_, fld, a.pat);
     auto bblock = fold_block(env_, fld, a.block);
-    ret rec(pat=ppat, block=bblock, index=a.index);
+    ret rec(pat=ppat, block=bblock);
 }
 
 fn fold_arg[ENV](&ENV env, &ast_fold[ENV] fld, &arg a) -> arg {

src/comp/middle/resolve.rs

@@ -431,12 +431,7 @@ fn lookup_in_scope(&env e, list[scope] sc, ident id, namespace ns)
 
             case (scope_arm(?a)) {
                 if (ns == ns_value) {
-                    alt (a.index.find(id)) {
-                        case (some[def_id](?did)) {
-                            ret some(ast.def_binding(did));
-                        }
-                        case (_) {}
-                    }
+                    ret lookup_in_pat(id, *a.pat);
                 }
             }
         }
@@ -470,6 +465,24 @@ fn lookup_in_ty_params(ident id, &vec[ast.ty_param] ty_params)
     ret none[def];
 }
 
+fn lookup_in_pat(ident id, &ast.pat pat) -> Option.t[def] {
+    alt (pat.node) {
+        case (ast.pat_bind(?name, ?defid, _)) {
+            if (Str.eq(name, id)) { ret some(ast.def_binding(defid)); }
+        }
+        case (ast.pat_wild(_)) {}
+        case (ast.pat_lit(_, _)) {}
+        case (ast.pat_tag(_, ?pats, _, _)) {
+            for (@ast.pat p in pats) {
+                auto found = lookup_in_pat(id, *p);
+                if (found != none[def]) { ret found; }
+            }
+        }
+    }
+    ret none[def];
+}
+
+
 fn lookup_in_fn(ident id, &ast.fn_decl decl,
                 &vec[ast.ty_param] ty_params, namespace ns) -> Option.t[def] {
     if (ns == ns_value) {

src/comp/middle/typeck.rs

@@ -1463,8 +1463,7 @@ mod Pushdown {
                     auto block_1 = pushdown_block(fcx, expected, arm_0.block);
                     t = Demand.simple(fcx, e.span, t,
                                       block_ty(fcx.ccx.tcx, block_1));
-                    auto arm_1 = rec(pat=arm_0.pat, block=block_1,
-                                     index=arm_0.index);
+                    auto arm_1 = rec(pat=arm_0.pat, block=block_1);
                     arms_1 += vec(arm_1);
                 }
                 e_1 = ast.expr_alt(discrim, arms_1, triv_ann(t));
@@ -2266,7 +2265,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
                                                        block_0);
                 auto pat_1 = pats_1.(i);
                 auto arm = arms.(i);
-                auto arm_1 = rec(pat=pat_1, block=block_1, index=arm.index);
+                auto arm_1 = rec(pat=pat_1, block=block_1);
                 arms_1 += vec(arm_1);
                 i += 1u;
             }

src/comp/middle/typestate_check.rs

@@ -2184,8 +2184,7 @@ fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
 fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] {
     fn one(fn_info_map fm, &arm a) -> arm {
         ret rec(pat=a.pat,
-                 block=annotate_block(fm, a.block),
-                 index=a.index);
+                 block=annotate_block(fm, a.block));
     }
     auto f = bind one(fm,_);
     ret Vec.map[arm, arm](f, alts);