limit allocation to innermost Scope

[dherman]

Since V8 actually allocates handles using the current isolate's innermost HandleScope, but the Rust types do not statically prevent attempting to allocate a handle connected to an outer Scope, dynamically track the linked list of Scopes and disallow allocation to a Scope that is not the current innermost one.

This seems unfortunate for performance, but I'm not sure if there's a faster way. Ideally we'd prevent it statically.

[Qard]

You could hack it with macros.

Rather than:

pub extern fn make_an_array(call: &mut Call) {
  let result = Scope::run(|scope| {
    let mut array = scope.array(3);
    array.set(0, scope.integer(17));
    array.set(1, scope.integer(42));
    array.set(2, scope.integer(1999));
    call.set_return(array);
  });
}

you could have something like:

pub extern fn make_an_array(call: &mut Call) {
  let result = scope_run!({
    let mut array = v8_array!(3);
    array.set(0, v8_integer!(17));
    array.set(1, v8_integer!(42));
    array.set(2, v8_integer!(1999));
    call.set_return(array);
  });
}

I feel dirty just thinking about it.

[dherman]

I had another hacky idea but I think it's too painful to use: if we could exploit the borrowing rules that prevent multiple simultaneous borrows when one is mutable, maybe we could somehow force the client into a mutable borrow when nesting so that no other borrowing is legal for that duration. I'm not sure if this would work, but the problem is it means you have to declare all scope variables with mut when they're going to be nested, which would just be hacky and ugly.

[dherman]

Fixed in 3c596a0