librustc: Port free variable finding to the new visitor

Author: pcwalton

src/librustc/middle/freevars.rs

@@ -17,7 +17,9 @@ use middle::ty;
 
 use std::hashmap::HashMap;
 use syntax::codemap::span;
-use syntax::{ast, ast_util, oldvisit};
+use syntax::{ast, ast_util};
+use syntax::visit::{SimpleVisitor, SimpleVisitorVisitor, Visitor};
+use syntax::visit;
 
 // A vector of defs representing the free variables referred to in a function.
 // (The def_upvar will already have been stripped).
@@ -29,6 +31,53 @@ pub struct freevar_entry {
 pub type freevar_info = @~[@freevar_entry];
 pub type freevar_map = @mut HashMap<ast::NodeId, freevar_info>;
 
+struct FreeVarCollectingVisitor {
+    seen: @mut HashMap<ast::NodeId,()>,
+    refs: @mut ~[@freevar_entry],
+    def_map: resolve::DefMap,
+}
+
+impl Visitor<int> for FreeVarCollectingVisitor {
+    fn visit_item(&mut self, _: @ast::item, _: int) {
+        // Ignore!
+    }
+
+    fn visit_expr(&mut self, expr: @ast::expr, depth: int) {
+        match expr.node {
+          ast::expr_fn_block(*) => {
+            visit::walk_expr(self, expr, depth + 1)
+          }
+          ast::expr_path(*) | ast::expr_self => {
+              let mut i = 0;
+              match self.def_map.find(&expr.id) {
+                None => fail!("path not found"),
+                Some(&df) => {
+                  let mut def = df;
+                  while i < depth {
+                    match def {
+                      ast::def_upvar(_, inner, _, _) => { def = *inner; }
+                      _ => break
+                    }
+                    i += 1;
+                  }
+                  if i == depth { // Made it to end of loop
+                    let dnum = ast_util::def_id_of_def(def).node;
+                    if !self.seen.contains_key(&dnum) {
+                        self.refs.push(@freevar_entry {
+                            def: def,
+                            span: expr.span,
+                        });
+                        self.seen.insert(dnum, ());
+                    }
+                  }
+                }
+              }
+          }
+          _ => visit::walk_expr(self, expr, depth)
+        }
+    }
+}
+
 // Searches through part of the AST for all references to locals or
 // upvars in this frame and returns the list of definition IDs thus found.
 // Since we want to be able to collect upvars in some arbitrary piece
@@ -38,50 +87,30 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block)
     -> freevar_info {
     let seen = @mut HashMap::new();
     let refs = @mut ~[];
+    let mut visitor = FreeVarCollectingVisitor {
+        seen: seen,
+        refs: refs,
+        def_map: def_map,
+    };
+    visitor.visit_block(blk, 1);
+    return @(*refs).clone();
+}
 
-    fn ignore_item(_i: @ast::item, (_depth, _v): (int, oldvisit::vt<int>)) { }
-
-    let walk_expr: @fn(expr: @ast::expr, (int, oldvisit::vt<int>)) =
-        |expr, (depth, v)| {
-            match expr.node {
-              ast::expr_fn_block(*) => {
-                oldvisit::visit_expr(expr, (depth + 1, v))
-              }
-              ast::expr_path(*) | ast::expr_self => {
-                  let mut i = 0;
-                  match def_map.find(&expr.id) {
-                    None => fail!("path not found"),
-                    Some(&df) => {
-                      let mut def = df;
-                      while i < depth {
-                        match def {
-                          ast::def_upvar(_, inner, _, _) => { def = *inner; }
-                          _ => break
-                        }
-                        i += 1;
-                      }
-                      if i == depth { // Made it to end of loop
-                        let dnum = ast_util::def_id_of_def(def).node;
-                        if !seen.contains_key(&dnum) {
-                            refs.push(@freevar_entry {
-                                def: def,
-                                span: expr.span,
-                            });
-                            seen.insert(dnum, ());
-                        }
-                      }
-                    }
-                  }
-              }
-              _ => oldvisit::visit_expr(expr, (depth, v))
-            }
-        };
+struct FreeVarAnnotatingVisitor {
+    def_map: resolve::DefMap,
+    freevars: freevar_map,
+}
 
-    let v = oldvisit::mk_vt(@oldvisit::Visitor {visit_item: ignore_item,
-                                          visit_expr: walk_expr,
-                                          .. *oldvisit::default_visitor()});
-    (v.visit_block)(blk, (1, v));
-    return @(*refs).clone();
+impl SimpleVisitor for FreeVarAnnotatingVisitor {
+    fn visit_fn(&mut self,
+                _: &visit::fn_kind,
+                _: &ast::fn_decl,
+                blk: &ast::Block,
+                _: span,
+                nid: ast::NodeId) {
+        let vars = collect_freevars(self.def_map, blk);
+        self.freevars.insert(nid, vars);
+    }
 }
 
 // Build a map from every function and for-each body to a set of the
@@ -92,22 +121,14 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block)
 pub fn annotate_freevars(def_map: resolve::DefMap, crate: &ast::Crate) ->
    freevar_map {
     let freevars = @mut HashMap::new();
-
-    let walk_fn: @fn(&oldvisit::fn_kind,
-                     &ast::fn_decl,
-                     &ast::Block,
-                     span,
-                     ast::NodeId) = |_, _, blk, _, nid| {
-        let vars = collect_freevars(def_map, blk);
-        freevars.insert(nid, vars);
+    let visitor = @mut FreeVarAnnotatingVisitor {
+        def_map: def_map,
+        freevars: freevars,
     };
-
-    let visitor =
-        oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
-            visit_fn: walk_fn,
-            .. *oldvisit::default_simple_visitor()});
-    oldvisit::visit_crate(crate, ((), visitor));
-
+    let mut simple_visitor = SimpleVisitorVisitor {
+        simple_visitor: visitor as @mut SimpleVisitor,
+    };
+    visit::walk_crate(&mut simple_visitor, crate, ());
     return freevars;
 }