Move Error methods to C++

src/accessors.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/accessors.h"
 
 #include "src/api.h"
 #include "src/contexts.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
@@ skipping 1098 matching lines @@
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 Handle<AccessorInfo> Accessors::BoundFunctionNameInfo(
     Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->name_string(),
                       &BoundFunctionNameGetter, &ReconfigureToDataProperty,
                       attributes);
 }
 
+//
+// Accessors::ErrorStack
+//
+
+namespace {
+
+MaybeHandle<JSReceiver> ClearInternalStackTrace(Isolate* isolate,
+                                                Handle<JSObject> error) {
+  RETURN_ON_EXCEPTION(
+      isolate,
+      JSReceiver::SetProperty(error, isolate->factory()->stack_trace_symbol(),
+                              isolate->factory()->undefined_value(), STRICT),
+      JSReceiver);
+  return error;
+}
+
+MaybeHandle<Object> FormatStackTrace(Isolate* isolate, Handle<JSObject> error,
+                                     Handle<Object> stack_trace) {
+  // TODO(jgruber): Port FormatStackTrace from JS.
+  Handle<JSFunction> fun = isolate->error_format_stack_trace();
+
+  int argc = 2;
+  ScopedVector<Handle<Object>> argv(argc);
+  argv[0] = error;
+  argv[1] = stack_trace;
+
+  Handle<Object> formatted_stack_trace;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, formatted_stack_trace,
+      Execution::Call(isolate, fun, error, argc, argv.start()), Object);
+
+  return formatted_stack_trace;
+}
+
+}  // namespace
+
+void Accessors::ErrorStackGetter(
+    v8::Local<v8::Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
+  HandleScope scope(isolate);
+  Handle<Object> obj = Utils::OpenHandle(*info.Holder());
+
+  while (obj->IsJSObject()) {
+    Handle<JSObject> holder = Handle<JSObject>::cast(obj);
+    Handle<Object> formatted_stack_trace;
+
+    Handle<Object> stack_trace;
+    Handle<Symbol> stack_trace_symbol =
+        isolate->factory()->stack_trace_symbol();
+    MaybeHandle<Object> maybe_stack_trace =
+        JSObject::GetProperty(holder, stack_trace_symbol);
+    if (!maybe_stack_trace.ToHandle(&stack_trace) ||
+        stack_trace->IsUndefined(isolate)) {
+      // The structured stack trace is not available. Look further up the

[Yang, 2016/07/19 11:34:59]

Can this actually happen? If this is some obscure edge case, we could just
return undefined.

The Javascript code had to do this because "this" is the receiver, not
necessarily the holder. So we had to manually walk the prototype chain to find
the actual holder. Here we do have the holder.

[jgruber, 2016/07/19 13:21:50]

Done.

+      // prototype chain.
+      obj = JSReceiver::GetPrototype(isolate, holder).ToHandleChecked();
+      continue;
+    }
+
+    if (!FormatStackTrace(isolate, holder, stack_trace)
+             .ToHandle(&formatted_stack_trace)) {
+      isolate->OptionalRescheduleException(false);
+      return;
+    }
+
+    MaybeHandle<Object> result = ClearInternalStackTrace(isolate, holder);
+    if (result.is_null()) {
+      isolate->OptionalRescheduleException(false);
+      return;
+    }
+
+    Handle<Object> receiver = Utils::OpenHandle(*info.This());
+    Handle<Name> name = Utils::OpenHandle(*key);
+    result = ReplaceAccessorWithDataProperty(isolate, receiver, holder, name,
+                                             formatted_stack_trace);
+    if (result.is_null()) {
+      isolate->OptionalRescheduleException(false);
+      return;
+    }
+
+    v8::Local<v8::Value> value = Utils::ToLocal(formatted_stack_trace);
+    info.GetReturnValue().Set(value);
+    return;
+  }
+
+  Handle<Object> result = isolate->factory()->undefined_value();
+  info.GetReturnValue().Set(Utils::ToLocal(result));
+}
+
+void Accessors::ErrorStackSetter(v8::Local<v8::Name> name,
+                                 v8::Local<v8::Value> val,
+                                 const v8::PropertyCallbackInfo<void>& info) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
+  HandleScope scope(isolate);
+  Handle<JSObject> obj =
+      Handle<JSObject>::cast(Utils::OpenHandle(*info.This()));
+
+  // Clear internal properties to avoid memory leaks.
+  Handle<Symbol> stack_trace_symbol = isolate->factory()->stack_trace_symbol();
+  if (JSReceiver::HasOwnProperty(obj, stack_trace_symbol).FromMaybe(false)) {
+    ClearInternalStackTrace(isolate, obj);
+  }
+
+  Accessors::ReconfigureToDataProperty(name, val, info);
+}
+
+Handle<AccessorInfo> Accessors::ErrorStackInfo(Isolate* isolate,
+                                               PropertyAttributes attributes) {
+  Handle<AccessorInfo> info =
+      MakeAccessor(isolate, isolate->factory()->stack_string(),
+                   &ErrorStackGetter, &ErrorStackSetter, attributes);
+  return info;
+}
 
 }  // namespace internal
 }  // namespace v8