Closures

Capture Policy

The following assumes no dataflow analysis.

If a captured var is modified, it needs to be allocated on the heap.

Modified (always with respect to closures in the following) means that it's being assigned to after any closure capturing that var has been instantiated, where that modification may happen either in an outer scope (from the closures perspective) or within the closure.

{
  var v = 1;
  v+=1;
  (function() v+=1)();
}

In the above code, v is not being modified WRT the closure, while in the code below it is.

{
  var v = 1;
  (function() v+=1)();
  v+=1;
}

Instead of allocating one single-element array per captured&modified var, we combine all captured variables into one object. The first closure context that is being created unconditionally in a given scope always hosts these captured variables. If there is no such closure, as e.g. in the case below, we allocate one independent object per scope, that holds the captured&modified vars.

function f(cond){
  var v = 1;
  if(cond) (function() v+=1)() else (function() v+=2)()
}

A scope in that context can be either a functions root scope, or the scope of a loop within a root scope.

function f(cond){
  // start of root scope
  var v = 1;
  if(cond) /* we're still in the root scope here */ (function() v+=1)() 
     else /* and here too */ (function() v+=2)()
  for (i in 0...v){ 
     /* start of a loop scope, captured & modified vars in this scope need their own object,
        the same rules regarding closures being created (un)conditionally apply here. */
     var x = 1;
     (function() x+=1)()
     x +=1;
  }
}