Fix closure capturing bug with for loops

2 files changed, 7 insertions, 2 deletions

diff --git a/src/model/eval.rs b/src/model/eval.rs
index 166dadde..43cdbbcc 100644
--- a/src/model/eval.rs
+++ b/src/model/eval.rs
@@ -1008,10 +1008,11 @@ impl Eval for ast::ForLoop {
     fn eval(&self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let flow = vm.flow.take();
         let mut output = Value::None;
-        vm.scopes.enter();
 
         macro_rules! iter {
             (for ($($binding:ident => $value:ident),*) in $iter:expr) => {{
+                vm.scopes.enter();
+
                 #[allow(unused_parens)]
                 for ($($value),*) in $iter {
                     $(vm.scopes.top.define($binding.clone(), $value);)*
@@ -1031,10 +1032,12 @@ impl Eval for ast::ForLoop {
                     }
                 }
 
+                vm.scopes.exit();
             }};
         }
 
         let iter = self.iter().eval(vm)?;
+
         let pattern = self.pattern();
         let key = pattern.key().map(ast::Ident::take);
         let value = pattern.value().take();
@@ -1076,7 +1079,6 @@ impl Eval for ast::ForLoop {
             vm.flow = flow;
         }
 
-        vm.scopes.exit();
         Ok(output)
     }
 }
diff --git a/src/model/func.rs b/src/model/func.rs
index dcb82027..60f36bd4 100644
--- a/src/model/func.rs
+++ b/src/model/func.rs
@@ -329,12 +329,14 @@ impl<'a> CapturesVisitor<'a> {
             // evaluated.
             Some(ast::Expr::For(expr)) => {
                 self.visit(expr.iter().as_untyped());
+                self.internal.enter();
                 let pattern = expr.pattern();
                 if let Some(key) = pattern.key() {
                     self.bind(key);
                 }
                 self.bind(pattern.value());
                 self.visit(expr.body().as_untyped());
+                self.internal.exit();
             }
 
             // An import contains items, but these are active only after the
@@ -416,6 +418,7 @@ mod tests {
         // For loop.
         test("#for x in y { x + z }", &["y", "z"]);
         test("#for x, y in y { x + y }", &["y"]);
+        test("#for x in y {} #x", &["x", "y"]);
 
         // Import.
         test("#import x, y from z", &["z"]);