Disallow variable names that shadow tags in scope

Now, if you have a tag named "foo", a variable declaration like
"let foo..." is illegal. This change makes it possible to eliminate
the '.' after a nullary tag pattern in an alt (but I'll be doing
that in a future commit) -- as now it's always obvious whether a
name refers to a tag or a new declared variable.

resolve implements this change -- all the other changes are just to
get rid of existing code that declares variables that shadow tag
names.

Author: catamorphism

src/comp/metadata/tydecode.rs

@@ -305,13 +305,13 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
 }
 
 fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt {
-    let mut;
+    let m;
     alt peek(st) as char {
-      'm' { next(st); mut = ast::mut; }
-      '?' { next(st); mut = ast::maybe_mut; }
-      _ { mut = ast::imm; }
+      'm' { next(st); m = ast::mut; }
+      '?' { next(st); m = ast::maybe_mut; }
+      _ { m = ast::imm; }
     }
-    ret {ty: parse_ty(st, conv), mut: mut};
+    ret {ty: parse_ty(st, conv), mut: m};
 }
 
 fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id {

src/comp/middle/last_use.rs

@@ -220,18 +220,18 @@ fn join_branches(branches: [set]) -> set {
         i += 1u;
         for {def, exprs} in set {
             if !vec::any(found, {|v| v.def == def}) {
-                let j = i, ne = exprs;
+                let j = i, nne = exprs;
                 while j < l {
                     for {def: d2, exprs} in branches[j] {
                         if d2 == def {
                             list::iter(exprs) {|e|
-                                if !list::has(ne, e) { ne = cons(e, @ne); }
+                                if !list::has(nne, e) { nne = cons(e, @nne); }
                             }
                         }
                     }
                     j += 1u;
                 }
-                found += [{def: def, exprs: ne}];
+                found += [{def: def, exprs: nne}];
             }
         }
     }