[V8] Use Function.name in Error.stack

test/mjsunit/stack-traces.js

 // Copyright 2009 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 76 matching lines @@
   function a$b$c$d() { return FAIL; }
   function Wookie() { }
   Wookie.prototype.d = a$b$c$d;
   (new Wookie).d();
 }
 
 function testAnonymousMethod() {
   (function () { FAIL }).call([1, 2, 3]);
 }
 
+function testFunctionName() {
+  function gen(name, counter) {
+    var f = function foo() {
+      if (counter === 0) {
+        FAIL;
+      }
+      gen(name, counter - 1)();
+    }
+    if (counter === 4) {
+      Object.defineProperty(f, 'name', {get: function(){ throw 239; }});
+    } else if (counter == 3) {
+      Object.defineProperty(f, 'name', {value: 'boo' + '_' + counter});
+    } else {
+      Object.defineProperty(f, 'name', {writable: true});
+      if (counter === 2)
+        f.name = 42;
+      else
+        f.name = name + '_' + counter;
+    }
+    return f;
+  }
+  gen('foo', 4)();
+}
+
 function CustomError(message, stripPoint) {
   this.message = message;
   Error.captureStackTrace(this, stripPoint);
 }
 
 CustomError.prototype.toString = function () {
   return "CustomError: " + this.message;
 };
 
 function testDefaultCustomError() {
@@ skipping 147 matching lines @@
 testTrace("testNestedEval", testNestedEval, ["eval at Inner (eval at Outer"]);
 testTrace("testEvalWithSourceURL", testEvalWithSourceURL,
     [ "at Doo (res://name:1:18)" ]);
 testTrace("testNestedEvalWithSourceURL", testNestedEvalWithSourceURL,
     [" at Inner (res://inner-eval:1:20)",
      " at Outer (res://outer-eval:1:37)"]);
 testTrace("testValue", testValue, ["at Number.causeError"]);
 testTrace("testConstructor", testConstructor, ["new Plonk"]);
 testTrace("testRenamedMethod", testRenamedMethod, ["Wookie.a$b$c$d [as d]"]);
 testTrace("testAnonymousMethod", testAnonymousMethod, ["Array.<anonymous>"]);
+testTrace("testFunctionName", testFunctionName,
+    [" at foo_0 ", " at foo_1", " at foo ", " at boo_3 ", " at foo "]);

[Yang, 2015/03/10 10:48:55]

Do we test the inferred name code path? I thought the inferred name in this case
would be "f". You would of course have to assign an anonymous function to it in
order to not use shared->name().

[kozy, 2015/03/10 15:26:08]

Test added.

 testTrace("testDefaultCustomError", testDefaultCustomError,
     ["hep-hey", "new CustomError"],
     ["collectStackTrace"]);
 testTrace("testStrippedCustomError", testStrippedCustomError, ["hep-hey"],
     ["new CustomError", "collectStackTrace"]);
 testTrace("testClassNames", testClassNames,
           ["new MyObj", "MyObjCreator.Create"], ["as Create"]);
 testCallerCensorship();
 testUnintendedCallerCensorship();
 testErrorsDuringFormatting();
@@ skipping 70 matching lines @@
 
 my_error = {};
 Object.preventExtensions(my_error);
 assertThrows(function() { Error.captureStackTrace(my_error); });
 
 var fake_error = {};
 my_error = new Error();
 var stolen_getter = Object.getOwnPropertyDescriptor(my_error, 'stack').get;
 Object.defineProperty(fake_error, 'stack', { get: stolen_getter });
 assertEquals(undefined, fake_error.stack);