Fire 'stack' getter of error objects after GC.

src/messages.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 794 matching lines @@
   var script = %FunctionGetScript(this.fun);
   if (script && script.compilation_type == COMPILATION_TYPE_EVAL) {
     return "eval";
   }
   return null;
 }
 
 function CallSiteGetMethodName() {
   // See if we can find a unique property on the receiver that holds
   // this function.
   var ownName = this.fun.name;

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

If we ever change property descriptor for our 'name' property on functions then
I would be able to detect GC by placing getter on it.

   if (ownName && this.receiver &&
       (%_CallFunction(this.receiver,
                       ownName,
                       ObjectLookupGetter) === this.fun ||
        %_CallFunction(this.receiver,
                       ownName,
                       ObjectLookupSetter) === this.fun ||
        this.receiver[ownName] === this.fun)) {

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

I can detect GC through here by doing:

var obj = {
  foo: function foo() { throw new Error(); };
};

try {
  obj.foo();
} catch (e) {
  delete obj.foo;
  Object.defineProperty(obj, 'foo', {
    get: function () { print('GC!'); }
  });
  ERROR = e;
}

Needs a guard of the same sort as done below in for-in loop.

     // To handle DontEnum properties we guess that the method has
     // the same name as the function.
     return ownName;
   }
   var name = null;
   for (var prop in this.receiver) {
     if (%_CallFunction(this.receiver, prop, ObjectLookupGetter) === this.fun ||
         %_CallFunction(this.receiver, prop, ObjectLookupSetter) === this.fun ||
         (!%_CallFunction(this.receiver, prop, ObjectLookupGetter) &&
          this.receiver[prop] === this.fun)) {
@@ skipping 175 matching lines @@
         eval_origin += ")";
       } else {
         eval_origin += " (unknown source)";
       }
     }
   }
 
   return eval_origin;
 }
 
-function FormatStackTrace(error, frames) {
-  var lines = [];
+
+function FormatErrorString(error) {
   try {
-    lines.push(error.toString());
+    return %_CallFunction(error, ErrorToString);
   } catch (e) {
     try {
-      lines.push("<error: " + e + ">");
+      return "<error: " + e + ">";
     } catch (ee) {
-      lines.push("<error>");
+      return "<error>";
     }
   }
+}
+

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

one more empty line

+function GetStackFrames(raw_stack) {
+  var frames = [];
+  for (var i = 0; i < raw_stack.length; i += 4) {
+    var recv = raw_stack[i];
+    var fun = raw_stack[i + 1];
+    var code = raw_stack[i + 2];
+    var pc = raw_stack[i + 3];
+    var pos = %FunctionGetPositionForOffset(code, pc);
+    %_CallFunction(frames, new CallSite(recv, fun, pos), ArrayPush)

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

This code can still be broken (formatting detected) if one installs setters on
"0", "1", ... on Array.prototype or Object.prototype (ArrayPush calls normal
[[Put]]).

If we want to ensure that this code works despite any modifications that one
somebody does to array then most probably we also need to make frames
InternalArray and then convert it to a normal array via elements transfer before
the return.

The same goes for the lines below.

+  }
+  return frames;
+}
+

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

ditto

+function FormatStackTrace(error_string, frames) {
+  var lines = [error_string];
   for (var i = 0; i < frames.length; i++) {
     var frame = frames[i];
     var line;
     try {
-      line = frame.toString();
+      line = %_CallFunction(frame, CallSiteToString);
     } catch (e) {
       try {
         line = "<error: " + e + ">";
       } catch (ee) {
         // Any code that reaches this point is seriously nasty!
         line = "<error>";
       }
     }
-    lines.push("    at " + line);
+    %_CallFunction(lines, "    at " + line, ArrayPush);
   }
-  return lines.join("\n");
-}
-
-function FormatRawStackTrace(error, raw_stack) {
-  var frames = [ ];
-  for (var i = 0; i < raw_stack.length; i += 4) {
-    var recv = raw_stack[i];
-    var fun = raw_stack[i + 1];
-    var code = raw_stack[i + 2];
-    var pc = raw_stack[i + 3];
-    var pos = %FunctionGetPositionForOffset(code, pc);
-    frames.push(new CallSite(recv, fun, pos));
-  }
-  if (IS_FUNCTION($Error.prepareStackTrace)) {
-    return $Error.prepareStackTrace(error, frames);
-  } else {
-    return FormatStackTrace(error, frames);
-  }
+  return %_CallFunction(lines, "\n", ArrayJoin);
 }
 
 function GetTypeName(obj, requireConstructor) {

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

ditto

   var constructor = obj.receiver.constructor;
   if (!constructor) {
     return requireConstructor ? null :
         %_CallFunction(obj.receiver, ObjectToString);
   }
   var constructorName = constructor.name;
   if (!constructorName) {
     return requireConstructor ? null :
         %_CallFunction(obj.receiver, ObjectToString);
   }
   return constructorName;
 }
 
 function captureStackTrace(obj, cons_opt) {

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

ditto

   var stackTraceLimit = $Error.stackTraceLimit;
   if (!stackTraceLimit || !IS_NUMBER(stackTraceLimit)) return;
   if (stackTraceLimit < 0 || stackTraceLimit > 10000) {
     stackTraceLimit = 10000;
   }
   var raw_stack = %CollectStackTrace(obj,
                                      cons_opt ? cons_opt : captureStackTrace,
                                      stackTraceLimit);
+
+  // Don't be lazy if the error stack formatting is custom (observable).
+  if (IS_FUNCTION($Error.prepareStackTrace)) {
+    obj.stack = $Error.prepareStackTrace(obj, GetStackFrames(raw_stack));

[Vyacheslav Egorov (Google), 2012/12/10 14:46:45]

should we maybe catch an error if it flies from prepareStackTrace and replace
obj.stack with it or some other text to indicate "recursive" throw?

do we have a test case that checks such re-entrant throw?

+    return;
+  }
+
+  var error_string = FormatErrorString(obj);
   // Note that 'obj' and 'this' maybe different when called on objects that
   // have the error object on its prototype chain.  The getter replaces itself
   // with a data property as soon as the stack trace has been formatted.
   var getter = function() {
-    var value = FormatRawStackTrace(obj, raw_stack);
+    var value = FormatStackTrace(error_string, GetStackFrames(raw_stack));
     %DefineOrRedefineDataProperty(obj, 'stack', value, NONE);
     return value;
   };
+  %MarkOneShotGetter(getter);
+
   // The 'stack' property of the receiver is set as data property.  If
   // the receiver is the same as holder, this accessor pair is replaced.
   var setter = function(v) {
     %DefineOrRedefineDataProperty(this, 'stack', v, NONE);
   };
 
   %DefineOrRedefineAccessorProperty(obj, 'stack', getter, setter, DONT_ENUM);
 }
 
 
@@ skipping 126 matching lines @@
 // Boilerplate for exceptions for stack overflows. Used from
 // Isolate::StackOverflow().
 function SetUpStackOverflowBoilerplate() {
   var boilerplate = MakeRangeError('stack_overflow', []);
 
   // The raw stack trace is stored as hidden property of the copy of this
   // boilerplate error object.  Note that the receiver 'this' may not be that
   // error object copy, but can be found on the prototype chain of 'this'.
   // When the stack trace is formatted, this accessor property is replaced by
   // a data property.
+  var error_string = boilerplate.name + ": " + boilerplate.message;
+
   function getter() {
     var holder = this;
     while (!IS_ERROR(holder)) {
       holder = %GetPrototype(holder);
       if (holder == null) return MakeSyntaxError('illegal_access', []);
     }
     var raw_stack = %GetOverflowedRawStackTrace(holder);
-    var result = IS_ARRAY(raw_stack) ? FormatRawStackTrace(holder, raw_stack)
-                                     : void 0;
+    var result = IS_ARRAY(raw_stack)
+                     ? FormatStackTrace(error_string, GetStackFrames(raw_stack))
+                     : void 0;
     %DefineOrRedefineDataProperty(holder, 'stack', result, NONE);
     return result;
   }
+  %MarkOneShotGetter(getter);
 
   // The 'stack' property of the receiver is set as data property.  If
   // the receiver is the same as holder, this accessor pair is replaced.
   function setter(v) {
     %DefineOrRedefineDataProperty(this, 'stack', v, NONE);
   }
 
   %DefineOrRedefineAccessorProperty(
       boilerplate, 'stack', getter, setter, DONT_ENUM);
 
   return boilerplate;
 }
 
 var kStackOverflowBoilerplate = SetUpStackOverflowBoilerplate();