Question

I am trying to get the surrounding js code of the current scope as text. It’s meant to be embedded in a live editor afterwards. Is that possible? In the worst case, it can go through Rhino.

thanks a lot

Answer 1

In general, no. JavaScript does not provide a reliable way to introspect over variable definitions or the call stack.

arguments.callee and arguments.caller do provide introspection into the set of functions on the call stack as long as there are no recursive calls, so you can extract source code by walking that. But it can be defeated by

function defeatArgumentsCaller(f, args, called) {
  if (!called) { return defeatArgumentsCaller(f, args, true); }
  return f.apply(args);
}

function f() {
  defeatArgumentsCaller(g, []);
}

When f is called, g will be unable to determine that it was called by f by looking at arguments.caller.

function g() {
  var fn = arguments.callee;
  while (true) {
    alert(fn.name);
    var caller = fn.caller;
    // defaultArgumentsCaller is itself, not f.
    if (!caller || caller == fn) { break; }
    fn = caller;
  }
}

They don’t allow introspection over the set of defined symbols, e.g. those introduced via with or catch so any attempt to enumerate the available local variables at the ... in

function f(o) {
  try {
    throw null;
  } catch (e) {
    with (o) { 
      ...
    }
  }
}

by examining the call stack and function source code will miss some defined symbols.

The call stack is also different from the stack of closures. For example, in

function counter() {
  var n;
  return function (f) { return f(n++); };
}

counter()(eval);

eval runs in a context that has more symbols available than the call stack would suggest since counter is not on the call stack at the point eval is called.

Rhino allows access to the current scope as a Scriptable which exposes the getIds method which can be used to enumerate the names in the current stack frame, and you can walk up to higher stack frames via getPrototype.