Include stack trace to error message when constructing a new Error with another Error as argument.

test/cctest/test-api.cc

 // 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 13520 matching lines @@
       "  Object.prototype.__defineSetter__(prop, function() { throw prop; });\n"
       "}\n");
   CompileRun("throw 'exception';");
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
 }
 
 
 static void RethrowStackTraceHandler(v8::Handle<v8::Message> message,
                                      v8::Handle<v8::Value> data) {
   // Use the frame where JavaScript is called from.
-  v8::Handle<v8::String> error_message = message->Get();
   v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   int frame_count = stack_trace->GetFrameCount();
   CHECK_EQ(3, frame_count);
   int line_number[] = {1, 2, 5};
   for (int i = 0; i < frame_count; i++) {
     CHECK_EQ(line_number[i], stack_trace->GetFrame(i)->GetLineNumber());
   }
 }
 
@@ skipping 21 matching lines @@
       "  }                              \n"
       "}                                \n";
   v8::V8::AddMessageListener(RethrowStackTraceHandler);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowStackTraceHandler);
 }
 
 
+static void RethrowWrapStackTraceHandler(v8::Handle<v8::Message> message,
+                                         v8::Handle<v8::Value> data) {
+  // Use the frame where JavaScript is called from.
+  v8::Handle<v8::String> error_message = message->Get();
+  CHECK_EQ("Uncaught Error: ReferenceError: error is not defined\n"
+           "    at g (unknown source)\n"
+           "    at f (unknown source)\n"
+           "    at unknown source",
+           *v8::String::AsciiValue(error_message));
+  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+  CHECK(!stack_trace.IsEmpty());
+  int frame_count = stack_trace->GetFrameCount();
+  CHECK_EQ(2, frame_count);
+  int line_number[] = {3, 10};
+  for (int i = 0; i < frame_count; i++) {
+    CHECK_EQ(line_number[i], stack_trace->GetFrame(i)->GetLineNumber());
+  }
+}
+
+
+// Test that we only return the stack trace at the site where the exception
+// is first thrown (not where it is rethrown).
+TEST(RethrowWrapStackTrace) {
+  v8::HandleScope scope;
+  LocalContext env;
+  // We make sure that
+  // - the stack trace of the ReferenceError in g() is reported.
+  // - the stack trace is not overwritten when e1 is rethrown by t().
+  // - the stack trace of e2 does not overwrite that of e1.
+  const char* source =
+      "function g() { error; }               \n"
+      "function f() { g(); }                 \n"
+      "function t(e) { throw new Error(e); } \n"
+      "try {                                 \n"
+      "  f();                                \n"
+      "} catch (e1) {                        \n"
+      "  try {                               \n"
+      "    error;                            \n"
+      "  } catch (e2) {                      \n"
+      "    t(e1);                            \n"
+      "  }                                   \n"
+      "}                                     \n";
+  v8::V8::AddMessageListener(RethrowWrapStackTraceHandler);
+  v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
+  CompileRun(source);
+  v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
+  v8::V8::RemoveMessageListeners(RethrowWrapStackTraceHandler);
+}
+
+
 static void RethrowPrimitiveStackTraceHandler(v8::Handle<v8::Message> message,
                                               v8::Handle<v8::Value> data) {
-  v8::Handle<v8::String> error_message = message->Get();
   v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   int frame_count = stack_trace->GetFrameCount();
   CHECK_EQ(2, frame_count);
   int line_number[] = {3, 7};
   for (int i = 0; i < frame_count; i++) {
     CHECK_EQ(line_number[i], stack_trace->GetFrame(i)->GetLineNumber());
   }
 }
 
@@ skipping 17 matching lines @@
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowPrimitiveStackTraceHandler);
 }
 
 
 static void RethrowExistingStackTraceHandler(v8::Handle<v8::Message> message,
                                               v8::Handle<v8::Value> data) {
   // Use the frame where JavaScript is called from.
-  v8::Handle<v8::String> error_message = message->Get();
   v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   CHECK_EQ(1, stack_trace->GetFrameCount());
   CHECK_EQ(1, stack_trace->GetFrame(0)->GetLineNumber());
 }
 
 
 // Test that the stack trace is captured when the error object is created and
 // not where it is thrown.
 TEST(RethrowExistingStackTrace) {
@@ skipping 2420 matching lines @@
   CompileRun("throw 'exception';");
 }
 
 
 TEST(CallCompletedCallbackTwoExceptions) {
   v8::HandleScope scope;
   LocalContext env;
   v8::V8::AddCallCompletedCallback(CallCompletedCallbackException);
   CompileRun("throw 'first exception';");
 }