---

yaml
---
r: 112255
b: refs/heads/try
c: 186ac71
h: refs/heads/master
i:
  112253: 0b51b57
  112251: 5c8c4eb
  112247: 45c2c0e
  112239: c89def0
  112223: 9ea64c1
  112191: 724178f
  112127: 367f153
v: v3

Author: eddyb

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a692e9b1234ff6573b0cfbc39394d9222eb38f81
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b5dd3f05fe95168b5569d0f519636149479eb6ac
-refs/heads/try: 1350fbdb24a06bd389cf1617ad5b78289a0c2354
+refs/heads/try: 186ac7116c555ba90031eab71fa27dd71326bf6a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/middle/astencode.rs

@@ -526,7 +526,7 @@ impl tr for ty::TraitStore {
 // ______________________________________________________________________
 // Encoding and decoding of freevar information
 
-fn encode_freevar_entry(ebml_w: &mut Encoder, fv: @freevar_entry) {
+fn encode_freevar_entry(ebml_w: &mut Encoder, fv: &freevar_entry) {
     (*fv).encode(ebml_w).unwrap();
 }
 
@@ -1018,7 +1018,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val, |ebml_w| {
                 ebml_w.emit_from_vec(fv.as_slice(), |ebml_w, fv_entry| {
-                    Ok(encode_freevar_entry(ebml_w, *fv_entry))
+                    Ok(encode_freevar_entry(ebml_w, fv_entry))
                 });
             })
         })
@@ -1370,8 +1370,8 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext,
                         dcx.tcx.node_type_substs.borrow_mut().insert(id, tys);
                     }
                     c::tag_table_freevars => {
-                        let fv_info = @val_dsr.read_to_vec(|val_dsr| {
-                            Ok(@val_dsr.read_freevar_entry(xcx))
+                        let fv_info = val_dsr.read_to_vec(|val_dsr| {
+                            Ok(val_dsr.read_freevar_entry(xcx))
                         }).unwrap().move_iter().collect();
                         dcx.tcx.freevars.borrow_mut().insert(id, fv_info);
                     }

branches/try/src/librustc/middle/freevars.rs

@@ -29,12 +29,11 @@ pub struct freevar_entry {
     pub def: ast::Def, //< The variable being accessed free.
     pub span: Span     //< First span where it is accessed (there can be multiple)
 }
-pub type freevar_info = @Vec<@freevar_entry> ;
-pub type freevar_map = NodeMap<freevar_info>;
+pub type freevar_map = NodeMap<Vec<freevar_entry>>;
 
 struct CollectFreevarsVisitor<'a> {
     seen: NodeSet,
-    refs: Vec<@freevar_entry>,
+    refs: Vec<freevar_entry>,
     def_map: &'a resolve::DefMap,
 }
 
@@ -65,7 +64,7 @@ impl<'a> Visitor<int> for CollectFreevarsVisitor<'a> {
                         if i == depth { // Made it to end of loop
                             let dnum = ast_util::def_id_of_def(def).node;
                             if !self.seen.contains(&dnum) {
-                                self.refs.push(@freevar_entry {
+                                self.refs.push(freevar_entry {
                                     def: def,
                                     span: expr.span,
                                 });
@@ -87,15 +86,15 @@ impl<'a> Visitor<int> for CollectFreevarsVisitor<'a> {
 // Since we want to be able to collect upvars in some arbitrary piece
 // of the AST, we take a walker function that we invoke with a visitor
 // in order to start the search.
-fn collect_freevars(def_map: &resolve::DefMap, blk: &ast::Block) -> freevar_info {
+fn collect_freevars(def_map: &resolve::DefMap, blk: &ast::Block) -> Vec<freevar_entry> {
     let mut v = CollectFreevarsVisitor {
         seen: NodeSet::new(),
         refs: Vec::new(),
         def_map: def_map,
     };
 
     v.visit_block(blk, 1);
-    @v.refs
+    v.refs
 }
 
 struct AnnotateFreevarsVisitor<'a> {
@@ -128,9 +127,9 @@ pub fn annotate_freevars(def_map: &resolve::DefMap, krate: &ast::Crate) ->
     visitor.freevars
 }
 
-pub fn get_freevars(tcx: &ty::ctxt, fid: ast::NodeId) -> freevar_info {
+pub fn with_freevars<T>(tcx: &ty::ctxt, fid: ast::NodeId, f: |&[freevar_entry]| -> T) -> T {
     match tcx.freevars.borrow().find(&fid) {
-        None => fail!("get_freevars: {} has no freevars", fid),
-        Some(&d) => return d
+        None => fail!("with_freevars: {} has no freevars", fid),
+        Some(d) => f(d.as_slice())
     }
 }

branches/try/src/librustc/middle/kind.rs

@@ -163,7 +163,7 @@ fn check_item(cx: &mut Context, item: &Item) {
 // closure.
 fn with_appropriate_checker(cx: &Context,
                             id: NodeId,
-                            b: |checker: |&Context, @freevar_entry||) {
+                            b: |checker: |&Context, &freevar_entry||) {
     fn check_for_uniq(cx: &Context, fv: &freevar_entry, bounds: ty::BuiltinBounds) {
         // all captured data must be owned, regardless of whether it is
         // moved in or copied in.
@@ -184,7 +184,7 @@ fn with_appropriate_checker(cx: &Context,
                              bounds, Some(var_t));
     }
 
-    fn check_for_bare(cx: &Context, fv: @freevar_entry) {
+    fn check_for_bare(cx: &Context, fv: &freevar_entry) {
         cx.tcx.sess.span_err(
             fv.span,
             "can't capture dynamic environment in a fn item; \
@@ -223,10 +223,11 @@ fn check_fn(
 
     // Check kinds on free variables:
     with_appropriate_checker(cx, fn_id, |chk| {
-        let r = freevars::get_freevars(cx.tcx, fn_id);
-        for fv in r.iter() {
-            chk(cx, *fv);
-        }
+        freevars::with_freevars(cx.tcx, fn_id, |r| {
+            for fv in r.iter() {
+                chk(cx, fv);
+            }
+        })
     });
 
     visit::walk_fn(cx, fk, decl, body, sp, fn_id, ());

branches/try/src/librustc/middle/moves.rs

@@ -544,7 +544,7 @@ impl<'a> VisitContext<'a> {
                     self.use_pat(a.pat);
                 }
                 let cap_vars = self.compute_captures(expr.id);
-                self.move_maps.capture_map.insert(expr.id, cap_vars);
+                self.move_maps.capture_map.insert(expr.id, Rc::new(cap_vars));
                 self.consume_block(body);
             }
 
@@ -639,34 +639,35 @@ impl<'a> VisitContext<'a> {
         self.consume_expr(arg_expr)
     }
 
-    pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> Rc<Vec<CaptureVar> > {
+    fn compute_captures(&mut self, fn_expr_id: NodeId) -> Vec<CaptureVar> {
         debug!("compute_capture_vars(fn_expr_id={:?})", fn_expr_id);
         let _indenter = indenter();
 
         let fn_ty = ty::node_id_to_type(self.tcx, fn_expr_id);
-        let freevars = freevars::get_freevars(self.tcx, fn_expr_id);
-        Rc::new(match ty::ty_closure_store(fn_ty) {
-            ty::RegionTraitStore(..) => {
-                // || captures everything by ref
-                freevars.iter()
-                        .map(|fvar| CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef})
-                        .collect()
-            }
-            ty::UniqTraitStore => {
-                // proc captures by copy or by move depending on type
-                freevars.iter()
-                        .map(|fvar| {
-                    let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
-                    let fvar_ty = ty::node_id_to_type(self.tcx, fvar_def_id);
-                    debug!("fvar_def_id={:?} fvar_ty={}",
-                        fvar_def_id, ppaux::ty_to_str(self.tcx, fvar_ty));
-                    let mode = if ty::type_moves_by_default(self.tcx, fvar_ty) {
-                        CapMove
-                    } else {
-                        CapCopy
-                    };
-                    CaptureVar {def: fvar.def, span: fvar.span, mode:mode}
-                }).collect()
+        freevars::with_freevars(self.tcx, fn_expr_id, |freevars| {
+            match ty::ty_closure_store(fn_ty) {
+                ty::RegionTraitStore(..) => {
+                    // || captures everything by ref
+                    freevars.iter()
+                            .map(|fvar| CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef})
+                            .collect()
+                }
+                ty::UniqTraitStore => {
+                    // proc captures by copy or by move depending on type
+                    freevars.iter()
+                            .map(|fvar| {
+                        let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
+                        let fvar_ty = ty::node_id_to_type(self.tcx, fvar_def_id);
+                        debug!("fvar_def_id={:?} fvar_ty={}",
+                            fvar_def_id, ppaux::ty_to_str(self.tcx, fvar_ty));
+                        let mode = if ty::type_moves_by_default(self.tcx, fvar_ty) {
+                            CapMove
+                        } else {
+                            CapCopy
+                        };
+                        CaptureVar {def: fvar.def, span: fvar.span, mode:mode}
+                    }).collect()
+                }
             }
         })
     }

branches/try/src/librustc/middle/typeck/check/regionck.rs

@@ -611,20 +611,21 @@ fn check_expr_fn_block(rcx: &mut Rcx,
     match ty::get(function_type).sty {
         ty::ty_closure(~ty::ClosureTy {
                 store: ty::RegionTraitStore(region, _), ..}) => {
-            let freevars = freevars::get_freevars(tcx, expr.id);
-            if freevars.is_empty() {
-                // No free variables means that the environment
-                // will be NULL at runtime and hence the closure
-                // has static lifetime.
-            } else {
-                // Closure must not outlive the variables it closes over.
-                constrain_free_variables(rcx, region, expr, freevars);
-
-                // Closure cannot outlive the appropriate temporary scope.
-                let s = rcx.repeating_scope;
-                rcx.fcx.mk_subr(true, infer::InfStackClosure(expr.span),
-                                region, ty::ReScope(s));
-            }
+            freevars::with_freevars(tcx, expr.id, |freevars| {
+                if freevars.is_empty() {
+                    // No free variables means that the environment
+                    // will be NULL at runtime and hence the closure
+                    // has static lifetime.
+                } else {
+                    // Closure must not outlive the variables it closes over.
+                    constrain_free_variables(rcx, region, expr, freevars);
+
+                    // Closure cannot outlive the appropriate temporary scope.
+                    let s = rcx.repeating_scope;
+                    rcx.fcx.mk_subr(true, infer::InfStackClosure(expr.span),
+                                    region, ty::ReScope(s));
+                }
+            });
         }
         _ => ()
     }
@@ -635,16 +636,17 @@ fn check_expr_fn_block(rcx: &mut Rcx,
 
     match ty::get(function_type).sty {
         ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(..), ..}) => {
-            let freevars = freevars::get_freevars(tcx, expr.id);
-            propagate_upupvar_borrow_kind(rcx, expr, freevars);
+            freevars::with_freevars(tcx, expr.id, |freevars| {
+                propagate_upupvar_borrow_kind(rcx, expr, freevars);
+            });
         }
         _ => ()
     }
 
     fn constrain_free_variables(rcx: &mut Rcx,
                                 region: ty::Region,
                                 expr: &ast::Expr,
-                                freevars: freevars::freevar_info) {
+                                freevars: &[freevars::freevar_entry]) {
         /*!
          * Make sure that all free variables referenced inside the closure
          * outlive the closure itself. Also, create an entry in the
@@ -690,7 +692,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
 
     fn propagate_upupvar_borrow_kind(rcx: &mut Rcx,
                                      expr: &ast::Expr,
-                                     freevars: freevars::freevar_info) {
+                                     freevars: &[freevars::freevar_entry]) {
         let tcx = rcx.fcx.ccx.tcx;
         debug!("propagate_upupvar_borrow_kind({})", expr.repr(tcx));
         for freevar in freevars.iter() {