---

yaml
---
r: 82618
b: refs/heads/auto
c: 04ca6dc
h: refs/heads/master
v: v3

Author: huonw

[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: 339027ec157757e903bc23ad0eed11e8a75867fa
+refs/heads/auto: 04ca6dcd84d7c5c24ff7bb9b74233fbbae5dd53d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/middle/region.rs

@@ -65,21 +65,18 @@ pub struct RegionMaps {
 
 #[deriving(Clone)]
 pub struct Context {
-    // Scope where variables should be parented to
-    var_parent: Option<ast::NodeId>,
-
-    // Innermost enclosing expression
-    parent: Option<ast::NodeId>,
-}
-
-struct RegionResolutionVisitor {
     sess: Session,
     def_map: resolve::DefMap,
 
     // Generated maps:
     region_maps: @mut RegionMaps,
-}
 
+    // Scope where variables should be parented to
+    var_parent: Option<ast::NodeId>,
+
+    // Innermost enclosing expression
+    parent: Option<ast::NodeId>,
+}
 
 impl RegionMaps {
     pub fn relate_free_regions(&mut self, sub: FreeRegion, sup: FreeRegion) {
@@ -321,24 +318,24 @@ impl RegionMaps {
 }
 
 /// Records the current parent (if any) as the parent of `child_id`.
-fn parent_to_expr(visitor: &mut RegionResolutionVisitor,
-                  cx: Context, child_id: ast::NodeId, sp: Span) {
+fn parent_to_expr(cx: Context, child_id: ast::NodeId, sp: Span) {
     debug!("region::parent_to_expr(span=%?)",
-           visitor.sess.codemap.span_to_str(sp));
+           cx.sess.codemap.span_to_str(sp));
     for parent_id in cx.parent.iter() {
-        visitor.region_maps.record_parent(child_id, *parent_id);
+        cx.region_maps.record_parent(child_id, *parent_id);
     }
 }
 
 fn resolve_block(visitor: &mut RegionResolutionVisitor,
                  blk: &ast::Block,
                  cx: Context) {
     // Record the parent of this block.
-    parent_to_expr(visitor, cx, blk.id, blk.span);
+    parent_to_expr(cx, blk.id, blk.span);
 
     // Descend.
     let new_cx = Context {var_parent: Some(blk.id),
-                          parent: Some(blk.id)};
+                          parent: Some(blk.id),
+                          ..cx};
     visit::walk_block(visitor, blk, new_cx);
 }
 
@@ -352,7 +349,7 @@ fn resolve_pat(visitor: &mut RegionResolutionVisitor,
                pat: @ast::Pat,
                cx: Context) {
     assert_eq!(cx.var_parent, cx.parent);
-    parent_to_expr(visitor, cx, pat.id, pat.span);
+    parent_to_expr(cx, pat.id, pat.span);
     visit::walk_pat(visitor, pat, cx);
 }
 
@@ -365,18 +362,18 @@ fn resolve_stmt(visitor: &mut RegionResolutionVisitor,
         }
         ast::StmtExpr(_, stmt_id) |
         ast::StmtSemi(_, stmt_id) => {
-            parent_to_expr(visitor, cx, stmt_id, stmt.span);
+            parent_to_expr(cx, stmt_id, stmt.span);
             let expr_cx = Context {parent: Some(stmt_id), ..cx};
             visit::walk_stmt(visitor, stmt, expr_cx);
         }
-        ast::StmtMac(*) => visitor.sess.bug("unexpanded macro")
+        ast::StmtMac(*) => cx.sess.bug("unexpanded macro")
     }
 }
 
 fn resolve_expr(visitor: &mut RegionResolutionVisitor,
                 expr: @ast::Expr,
                 cx: Context) {
-    parent_to_expr(visitor, cx, expr.id, expr.span);
+    parent_to_expr(cx, expr.id, expr.span);
 
     let mut new_cx = cx;
     new_cx.parent = Some(expr.id);
@@ -418,7 +415,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
                  local: @ast::Local,
                  cx: Context) {
     assert_eq!(cx.var_parent, cx.parent);
-    parent_to_expr(visitor, cx, local.id, local.span);
+    parent_to_expr(cx, local.id, local.span);
     visit::walk_local(visitor, local, cx);
 }
 
@@ -442,7 +439,7 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor,
                                body.id=%?, \
                                cx.parent=%?)",
            id,
-           visitor.sess.codemap.span_to_str(sp),
+           cx.sess.codemap.span_to_str(sp),
            body.id,
            cx.parent);
 
@@ -452,7 +449,7 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor,
                            ..cx};
     match *fk {
         visit::fk_method(_, _, method) => {
-            visitor.region_maps.record_parent(method.self_id, body.id);
+            cx.region_maps.record_parent(method.self_id, body.id);
         }
         _ => {}
     }
@@ -473,6 +470,8 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor,
     visitor.visit_block(body, body_cx);
 }
 
+struct RegionResolutionVisitor;
+
 impl Visitor<Context> for RegionResolutionVisitor {
 
     fn visit_block(&mut self, b:&Block, cx:Context) {
@@ -512,13 +511,12 @@ pub fn resolve_crate(sess: Session,
         free_region_map: HashMap::new(),
         cleanup_scopes: HashSet::new(),
     };
-    let cx = Context {parent: None,
+    let cx = Context {sess: sess,
+                      def_map: def_map,
+                      region_maps: region_maps,
+                      parent: None,
                       var_parent: None};
-    let mut visitor = RegionResolutionVisitor {
-        sess: sess,
-        def_map: def_map,
-        region_maps: region_maps,
-    };
+    let mut visitor = RegionResolutionVisitor;
     visit::walk_crate(&mut visitor, crate, cx);
     return region_maps;
 }
@@ -735,9 +733,10 @@ impl DetermineRpCtxt {
 }
 
 fn determine_rp_in_item(visitor: &mut DetermineRpVisitor,
-                        item: @ast::item) {
-    do visitor.cx.with(item.id, true) {
-        visit::walk_item(visitor, item, ());
+                        item: @ast::item,
+                        cx: @mut DetermineRpCtxt) {
+    do cx.with(item.id, true) {
+        visit::walk_item(visitor, item, cx);
     }
 }
 
@@ -746,33 +745,32 @@ fn determine_rp_in_fn(visitor: &mut DetermineRpVisitor,
                       decl: &ast::fn_decl,
                       body: &ast::Block,
                       _: Span,
-                      _: ast::NodeId) {
-    let cx = visitor.cx;
+                      _: ast::NodeId,
+                      cx: @mut DetermineRpCtxt) {
     do cx.with(cx.item_id, false) {
         do cx.with_ambient_variance(rv_contravariant) {
             for a in decl.inputs.iter() {
-                visitor.visit_ty(&a.ty, ());
+                visitor.visit_ty(&a.ty, cx);
             }
         }
-        visitor.visit_ty(&decl.output, ());
+        visitor.visit_ty(&decl.output, cx);
         let generics = visit::generics_of_fn(fk);
-        visitor.visit_generics(&generics, ());
-        visitor.visit_block(body, ());
+        visitor.visit_generics(&generics, cx);
+        visitor.visit_block(body, cx);
     }
 }
 
 fn determine_rp_in_ty_method(visitor: &mut DetermineRpVisitor,
-                             ty_m: &ast::TypeMethod) {
-    let cx = visitor.cx;
+                             ty_m: &ast::TypeMethod,
+                             cx: @mut DetermineRpCtxt) {
     do cx.with(cx.item_id, false) {
-        visit::walk_ty_method(visitor, ty_m, ());
+        visit::walk_ty_method(visitor, ty_m, cx);
     }
 }
 
 fn determine_rp_in_ty(visitor: &mut DetermineRpVisitor,
-                      ty: &ast::Ty) {
-    let cx = visitor.cx;
-
+                      ty: &ast::Ty,
+                      cx: @mut DetermineRpCtxt) {
     // we are only interested in types that will require an item to
     // be region-parameterized.  if cx.item_id is zero, then this type
     // is not a member of a type defn nor is it a constitutent of an
@@ -856,14 +854,14 @@ fn determine_rp_in_ty(visitor: &mut DetermineRpVisitor,
     match ty.node {
       ast::ty_box(ref mt) | ast::ty_uniq(ref mt) | ast::ty_vec(ref mt) |
       ast::ty_rptr(_, ref mt) | ast::ty_ptr(ref mt) => {
-        visit_mt(visitor, mt);
+        visit_mt(visitor, mt, cx);
       }
 
       ast::ty_path(ref path, _, _) => {
         // type parameters are---for now, anyway---always invariant
         do cx.with_ambient_variance(rv_invariant) {
             for tp in path.segments.iter().flat_map(|s| s.types.iter()) {
-                visitor.visit_ty(tp, ());
+                visitor.visit_ty(tp, cx);
             }
         }
       }
@@ -876,58 +874,57 @@ fn determine_rp_in_ty(visitor: &mut DetermineRpVisitor,
             // parameters are contravariant
             do cx.with_ambient_variance(rv_contravariant) {
                 for a in decl.inputs.iter() {
-                    visitor.visit_ty(&a.ty, ());
+                    visitor.visit_ty(&a.ty, cx);
                 }
             }
-            visitor.visit_ty(&decl.output, ());
+            visitor.visit_ty(&decl.output, cx);
         }
       }
 
       _ => {
-        visit::walk_ty(visitor, ty, ());
+        visit::walk_ty(visitor, ty, cx);
       }
     }
 
     fn visit_mt(visitor: &mut DetermineRpVisitor,
-                mt: &ast::mt) {
-        let cx = visitor.cx;
+                mt: &ast::mt,
+                cx: @mut DetermineRpCtxt) {
         // mutability is invariant
         if mt.mutbl == ast::MutMutable {
             do cx.with_ambient_variance(rv_invariant) {
-                visitor.visit_ty(mt.ty, ());
+                visitor.visit_ty(mt.ty, cx);
             }
         } else {
-            visitor.visit_ty(mt.ty, ());
+            visitor.visit_ty(mt.ty, cx);
         }
     }
 }
 
 fn determine_rp_in_struct_field(visitor: &mut DetermineRpVisitor,
-                                cm: @ast::struct_field) {
-    visit::walk_struct_field(visitor, cm, ());
+                                cm: @ast::struct_field,
+                                cx: @mut DetermineRpCtxt) {
+    visit::walk_struct_field(visitor, cm, cx);
 }
 
-struct DetermineRpVisitor {
-    cx: @mut DetermineRpCtxt
-}
+struct DetermineRpVisitor;
 
-impl Visitor<()> for DetermineRpVisitor {
+impl Visitor<@mut DetermineRpCtxt> for DetermineRpVisitor {
 
     fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl,
-                b:&Block, s:Span, n:NodeId, _:()) {
-        determine_rp_in_fn(self, fk, fd, b, s, n);
+                b:&Block, s:Span, n:NodeId, e:@mut DetermineRpCtxt) {
+        determine_rp_in_fn(self, fk, fd, b, s, n, e);
     }
-    fn visit_item(&mut self, i:@item, _:()) {
-        determine_rp_in_item(self, i);
+    fn visit_item(&mut self, i:@item, e:@mut DetermineRpCtxt) {
+        determine_rp_in_item(self, i, e);
     }
-    fn visit_ty(&mut self, t:&Ty, _:()) {
-        determine_rp_in_ty(self, t);
+    fn visit_ty(&mut self, t:&Ty, e:@mut DetermineRpCtxt) {
+        determine_rp_in_ty(self, t, e);
     }
-    fn visit_ty_method(&mut self, t:&TypeMethod, _:()) {
-        determine_rp_in_ty_method(self, t);
+    fn visit_ty_method(&mut self, t:&TypeMethod, e:@mut DetermineRpCtxt) {
+        determine_rp_in_ty_method(self, t, e);
     }
-    fn visit_struct_field(&mut self, s:@struct_field, _:()) {
-        determine_rp_in_struct_field(self, s);
+    fn visit_struct_field(&mut self, s:@struct_field, e:@mut DetermineRpCtxt) {
+        determine_rp_in_struct_field(self, s, e);
     }
 
 }
@@ -950,8 +947,8 @@ pub fn determine_rp_in_crate(sess: Session,
     };
 
     // Gather up the base set, worklist and dep_map
-    let mut visitor = DetermineRpVisitor { cx: cx };
-    visit::walk_crate(&mut visitor, crate, ());
+    let mut visitor = DetermineRpVisitor;
+    visit::walk_crate(&mut visitor, crate, cx);
 
     // Propagate indirect dependencies
     //