---

yaml
---
r: 82613
b: refs/heads/auto
c: 411dce8
h: refs/heads/master
i:
  82611: b2a8392
v: v3

Author: pnkfelix

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: eac429cc9e1e57ea9c91406dc149e7b1c79d86a0
+refs/heads/auto: 411dce85eadd4ef8abac9b538c8907ca20865bdd
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/middle/trans/type_use.rs

@@ -81,7 +81,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: DefId, n_tps: uint)
     // Conservatively assume full use for recursive loops
     ccx.type_use_cache.insert(fn_id, @vec::from_elem(n_tps, use_all));
 
-    let cx = Context {
+    let mut cx = Context {
         ccx: ccx,
         uses: @mut vec::from_elem(n_tps, 0u)
     };
@@ -112,7 +112,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: DefId, n_tps: uint)
       ast_map::node_item(@ast::item { node: item_fn(_, _, _, _, ref body),
                                       _ }, _) |
       ast_map::node_method(@ast::method {body: ref body, _}, _, _) => {
-        handle_body(&cx, body);
+        handle_body(&mut cx, body);
       }
       ast_map::node_trait_method(*) => {
         // This will be a static trait method. For now, we just assume
@@ -414,39 +414,36 @@ pub fn mark_for_expr(cx: &Context, e: &Expr) {
     }
 }
 
-struct TypeUseVisitor;
+impl Visitor<()> for Context {
 
-impl<'self> Visitor<&'self Context> for TypeUseVisitor {
-
-    fn visit_expr<'a>(&mut self, e:@Expr, cx: &'a Context) {
-            visit::walk_expr(self, e, cx);
-            mark_for_expr(cx, e);
+    fn visit_expr(&mut self, e:@Expr, _: ()) {
+            visit::walk_expr(self, e, ());
+            mark_for_expr(self, e);
     }
 
-    fn visit_local<'a>(&mut self, l:@Local, cx: &'a Context) {
-            visit::walk_local(self, l, cx);
-            node_type_needs(cx, use_repr, l.id);
+    fn visit_local(&mut self, l:@Local, _:()) {
+            visit::walk_local(self, l, ());
+            node_type_needs(self, use_repr, l.id);
     }
 
-    fn visit_pat<'a>(&mut self, p:@Pat, cx: &'a Context) {
-            visit::walk_pat(self, p, cx);
-            node_type_needs(cx, use_repr, p.id);
+    fn visit_pat(&mut self, p:@Pat, _: ()) {
+            visit::walk_pat(self, p, ());
+            node_type_needs(self, use_repr, p.id);
     }
 
-    fn visit_block<'a>(&mut self, b:&Block, cx: &'a Context) {
-            visit::walk_block(self, b, cx);
+   fn visit_block(&mut self, b:&Block, _: ()) {
+            visit::walk_block(self, b, ());
             for e in b.expr.iter() {
-                node_type_needs(cx, use_repr, e.id);
+                node_type_needs(self, use_repr, e.id);
             }
     }
 
-    fn visit_item<'a>(&mut self, _:@item, _: &'a Context) {
+    fn visit_item(&mut self, _:@item, _: ()) {
         // do nothing
     }
 
 }
 
-pub fn handle_body(cx: &Context, body: &Block) {
-    let mut v = TypeUseVisitor;
-    v.visit_block(body, cx);
+pub fn handle_body(cx: &mut Context, body: &Block) {
+    cx.visit_block(body, ());
 }