[Error.cause] Implement error cause tc39 proposal

https://github.com/tc39/proposal-error-cause

Bug: chromium:1192162
Change-Id: If6e2d1f105bb520104bb832ccbc7f660bb8115a1
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2784681
Auto-Submit: Victor Gomes <victorgomes@chromium.org>
Commit-Queue: Victor Gomes <victorgomes@chromium.org>
Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73855}

src/builtins/aggregate-error.tq

@@ -19,8 +19,9 @@ transitioning javascript builtin AggregateErrorConstructor(
   //   [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*
   //   c. Perform ! DefinePropertyOrThrow(_O_, *"message"*, _msgDesc_).
   const message: JSAny = arguments[1];
-  const obj: JSObject =
-      ConstructAggregateErrorHelper(context, target, newTarget, message);
+  const options: JSAny = arguments[2];
+  const obj: JSObject = ConstructAggregateErrorHelper(
+      context, target, newTarget, message, options);
 
   // 4. Let errorsList be ? IterableToList(errors).
   const errors: JSAny = arguments[0];
@@ -38,7 +39,7 @@ transitioning javascript builtin AggregateErrorConstructor(
 }
 
 extern transitioning runtime ConstructAggregateErrorHelper(
-    Context, JSFunction, JSAny, Object): JSObject;
+    Context, JSFunction, JSAny, Object, Object): JSObject;
 
 extern transitioning runtime ConstructInternalAggregateErrorHelper(
     Context, Object): JSObject;

src/builtins/builtins-error.cc

@@ -18,9 +18,12 @@ namespace internal {
 // ES6 section 19.5.1.1 Error ( message )
 BUILTIN(ErrorConstructor) {
   HandleScope scope(isolate);
+  Handle<Object> options = FLAG_harmony_error_cause
+                               ? args.atOrUndefined(isolate, 2)
+                               : isolate->factory()->undefined_value();
   RETURN_RESULT_OR_FAILURE(
       isolate, ErrorUtils::Construct(isolate, args.target(), args.new_target(),
-                                     args.atOrUndefined(isolate, 1)));
+                                     args.atOrUndefined(isolate, 1), options));
 }
 
 // static

src/execution/isolate.cc

@@ -1404,11 +1404,12 @@ Object Isolate::StackOverflow() {
   Handle<JSFunction> fun = range_error_function();
   Handle<Object> msg = factory()->NewStringFromAsciiChecked(
       MessageFormatter::TemplateString(MessageTemplate::kStackOverflow));
+  Handle<Object> options = factory()->undefined_value();
   Handle<Object> no_caller;
   Handle<Object> exception;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       this, exception,
-      ErrorUtils::Construct(this, fun, fun, msg, SKIP_NONE, no_caller,
+      ErrorUtils::Construct(this, fun, fun, msg, options, SKIP_NONE, no_caller,
                             ErrorUtils::StackTraceCollection::kSimple));
 
   Throw(*exception);

src/execution/messages.cc

@@ -483,7 +483,8 @@ MaybeHandle<String> MessageFormatter::Format(Isolate* isolate,
 MaybeHandle<JSObject> ErrorUtils::Construct(Isolate* isolate,
                                             Handle<JSFunction> target,
                                             Handle<Object> new_target,
-                                            Handle<Object> message) {
+                                            Handle<Object> message,
+                                            Handle<Object> options) {
   FrameSkipMode mode = SKIP_FIRST;
   Handle<Object> caller;
 
@@ -495,15 +496,15 @@ MaybeHandle<JSObject> ErrorUtils::Construct(Isolate* isolate,
     caller = new_target;
   }
 
-  return ErrorUtils::Construct(isolate, target, new_target, message, mode,
-                               caller,
+  return ErrorUtils::Construct(isolate, target, new_target, message, options,
+                               mode, caller,
                                ErrorUtils::StackTraceCollection::kDetailed);
 }
 
 MaybeHandle<JSObject> ErrorUtils::Construct(
     Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
-    Handle<Object> message, FrameSkipMode mode, Handle<Object> caller,
-    StackTraceCollection stack_trace_collection) {
+    Handle<Object> message, Handle<Object> options, FrameSkipMode mode,
+    Handle<Object> caller, StackTraceCollection stack_trace_collection) {
   if (FLAG_correctness_fuzzer_suppressions) {
     // Abort range errors in correctness fuzzing, as their causes differ
     // accross correctness-fuzzing scenarios.
@@ -536,7 +537,6 @@ MaybeHandle<JSObject> ErrorUtils::Construct(
   //     true, [[Enumerable]]: false, [[Configurable]]: true}.
   //  c. Perform ! DefinePropertyOrThrow(O, "message", msgDesc).
   // 4. Return O.
-
   if (!message->IsUndefined(isolate)) {
     Handle<String> msg_string;
     ASSIGN_RETURN_ON_EXCEPTION(isolate, msg_string,
@@ -548,6 +548,31 @@ MaybeHandle<JSObject> ErrorUtils::Construct(
         JSObject);
   }
 
+  if (FLAG_harmony_error_cause && !options->IsUndefined(isolate)) {
+    // If Type(options) is Object and ? HasProperty(options, "cause") then
+    //   a. Let cause be ? Get(options, "cause").
+    //   b. Perform ! CreateNonEnumerableDataPropertyOrThrow(O, "cause", cause).
+    Handle<Name> cause_string = isolate->factory()->cause_string();
+    if (options->IsJSReceiver()) {
+      Handle<JSReceiver> js_options = Handle<JSReceiver>::cast(options);
+      Maybe<bool> has_cause = JSObject::HasProperty(js_options, cause_string);
+      if (has_cause.IsNothing()) {
+        DCHECK((isolate)->has_pending_exception());
+        return MaybeHandle<JSObject>();
+      }
+      if (has_cause.ToChecked()) {
+        Handle<Object> cause;
+        ASSIGN_RETURN_ON_EXCEPTION(
+            isolate, cause,
+            JSObject::GetProperty(isolate, js_options, cause_string), JSObject);
+        RETURN_ON_EXCEPTION(isolate,
+                            JSObject::SetOwnPropertyIgnoreAttributes(
+                                err, cause_string, cause, DONT_ENUM),
+                            JSObject);
+      }
+    }
+  }
+
   switch (stack_trace_collection) {
     case StackTraceCollection::kDetailed:
       RETURN_ON_EXCEPTION(
@@ -676,14 +701,15 @@ Handle<JSObject> ErrorUtils::MakeGenericError(
     isolate->clear_pending_exception();
   }
   Handle<String> msg = DoFormatMessage(isolate, index, arg0, arg1, arg2);
+  Handle<Object> options = isolate->factory()->undefined_value();
 
   DCHECK(mode != SKIP_UNTIL_SEEN);
 
   Handle<Object> no_caller;
   // The call below can't fail because constructor is a builtin.
   DCHECK(constructor->shared().HasBuiltinId());
-  return ErrorUtils::Construct(isolate, constructor, constructor, msg, mode,
-                               no_caller, StackTraceCollection::kDetailed)
+  return ErrorUtils::Construct(isolate, constructor, constructor, msg, options,
+                               mode, no_caller, StackTraceCollection::kDetailed)
       .ToHandleChecked();
 }
 

src/execution/messages.h

@@ -77,11 +77,12 @@ class ErrorUtils : public AllStatic {
   static MaybeHandle<JSObject> Construct(Isolate* isolate,
                                          Handle<JSFunction> target,
                                          Handle<Object> new_target,
-                                         Handle<Object> message);
+                                         Handle<Object> message,
+                                         Handle<Object> options);
   static MaybeHandle<JSObject> Construct(
       Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
-      Handle<Object> message, FrameSkipMode mode, Handle<Object> caller,
-      StackTraceCollection stack_trace_collection);
+      Handle<Object> message, Handle<Object> options, FrameSkipMode mode,
+      Handle<Object> caller, StackTraceCollection stack_trace_collection);
 
   static MaybeHandle<String> ToString(Isolate* isolate, Handle<Object> recv);
 

src/flags/flag-definitions.h

@@ -283,7 +283,8 @@ DEFINE_IMPLICATION(harmony_weak_refs_with_cleanup_some, harmony_weak_refs)
 // Features that are complete (but still behind --harmony/es-staging flag).
 #define HARMONY_STAGED_BASE(V)                                              \
   V(harmony_relative_indexing_methods, "harmony relative indexing methods") \
-  V(harmony_class_static_blocks, "harmony static initializer blocks")
+  V(harmony_class_static_blocks, "harmony static initializer blocks")       \
+  V(harmony_error_cause, "harmony error cause property")
 
 #ifdef V8_INTL_SUPPORT
 #define HARMONY_STAGED(V)               \

src/heap/factory.cc

@@ -1892,7 +1892,7 @@ Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
 
   Handle<Object> no_caller;
   return ErrorUtils::Construct(isolate(), constructor, constructor, message,
-                               SKIP_NONE, no_caller,
+                               undefined_value(), SKIP_NONE, no_caller,
                                ErrorUtils::StackTraceCollection::kDetailed)
       .ToHandleChecked();
 }

src/init/bootstrapper.cc

@@ -1404,6 +1404,11 @@ static void InstallError(
     int error_function_length = 1, int in_object_properties = 2) {
   Factory* factory = isolate->factory();
 
+  if (FLAG_harmony_error_cause) {
+    error_function_length += 1;
+    in_object_properties += 1;
+  }
+
   // Most Error objects consist of a message and a stack trace.
   // Reserve two in-object properties for these.
   const int kErrorObjectSize =
@@ -1411,7 +1416,6 @@ static void InstallError(
   Handle<JSFunction> error_fun = InstallFunction(
       isolate, global, name, JS_ERROR_TYPE, kErrorObjectSize,
       in_object_properties, factory->the_hole_value(), error_constructor);
-  error_fun->shared().DontAdaptArguments();
   error_fun->shared().set_length(error_function_length);
 
   if (context_index == Context::ERROR_FUNCTION_INDEX) {
@@ -1431,6 +1435,11 @@ static void InstallError(
     JSObject::AddProperty(isolate, prototype, factory->message_string(),
                           factory->empty_string(), DONT_ENUM);
 
+    if (FLAG_harmony_error_cause) {
+      JSObject::AddProperty(isolate, prototype, factory->cause_string(),
+                            factory->undefined_value(), DONT_ENUM);
+    }
+
     if (context_index == Context::ERROR_FUNCTION_INDEX) {
       Handle<JSFunction> to_string_fun =
           SimpleInstallFunction(isolate, prototype, "toString",
@@ -4325,6 +4334,7 @@ EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_top_level_await)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_import_assertions)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_private_brand_checks)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_class_static_blocks)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_error_cause)
 
 #ifdef V8_INTL_SUPPORT
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_best_fit_matcher)

src/init/heap-symbols.h

@@ -152,6 +152,7 @@
   V(_, CompileError_string, "CompileError")                          \
   V(_, callee_string, "callee")                                      \
   V(_, caller_string, "caller")                                      \
+  V(_, cause_string, "cause")                                        \
   V(_, character_string, "character")                                \
   V(_, closure_string, "(closure)")                                  \
   V(_, code_string, "code")                                          \

src/objects/value-serializer.cc

@@ -227,6 +227,8 @@ enum class ErrorTag : uint8_t {
   kUriErrorPrototype = 'U',
   // Followed by message: string.
   kMessage = 'm',
+  // Followed by a JS object: cause.
+  kCause = 'c',
   // Followed by stack: string.
   kStack = 's',
   // The end of this error information.
@@ -935,6 +937,9 @@ Maybe<bool> ValueSerializer::WriteJSError(Handle<JSObject> error) {
   Maybe<bool> message_found = JSReceiver::GetOwnPropertyDescriptor(
       isolate_, error, isolate_->factory()->message_string(), &message_desc);
   MAYBE_RETURN(message_found, Nothing<bool>());
+  PropertyDescriptor cause_desc;
+  Maybe<bool> cause_found = JSReceiver::GetOwnPropertyDescriptor(
+      isolate_, error, isolate_->factory()->cause_string(), &cause_desc);
 
   WriteTag(SerializationTag::kError);
 
@@ -974,6 +979,15 @@ Maybe<bool> ValueSerializer::WriteJSError(Handle<JSObject> error) {
     WriteString(message);
   }
 
+  if (cause_found.FromJust() &&
+      PropertyDescriptor::IsDataDescriptor(&cause_desc)) {
+    Handle<Object> cause = cause_desc.value();
+    WriteVarint(static_cast<uint8_t>(ErrorTag::kCause));
+    if (!WriteObject(cause).FromMaybe(false)) {
+      return Nothing<bool>();
+    }
+  }
+
   if (!Object::GetProperty(isolate_, error, isolate_->factory()->stack_string())
            .ToHandle(&stack)) {
     return Nothing<bool>();
@@ -1875,6 +1889,7 @@ MaybeHandle<JSArrayBufferView> ValueDeserializer::ReadJSArrayBufferView(
 
 MaybeHandle<Object> ValueDeserializer::ReadJSError() {
   Handle<Object> message = isolate_->factory()->undefined_value();
+  Handle<Object> options = isolate_->factory()->undefined_value();
   Handle<Object> stack = isolate_->factory()->undefined_value();
   Handle<Object> no_caller;
   auto constructor = isolate_->error_function();
@@ -1912,6 +1927,20 @@ MaybeHandle<Object> ValueDeserializer::ReadJSError() {
         message = message_string;
         break;
       }
+      case ErrorTag::kCause: {
+        Handle<Object> cause;
+        if (!ReadObject().ToHandle(&cause)) {
+          return MaybeHandle<JSObject>();
+        }
+        options = isolate_->factory()->NewJSObject(isolate_->object_function());
+        if (JSObject::DefinePropertyOrElementIgnoreAttributes(
+                Handle<JSObject>::cast(options),
+                isolate_->factory()->cause_string(), cause, DONT_ENUM)
+                .is_null()) {
+          return MaybeHandle<JSObject>();
+        }
+        break;
+      }
       case ErrorTag::kStack: {
         Handle<String> stack_string;
         if (!ReadString().ToHandle(&stack_string)) {
@@ -1930,7 +1959,7 @@ MaybeHandle<Object> ValueDeserializer::ReadJSError() {
 
   Handle<Object> error;
   if (!ErrorUtils::Construct(isolate_, constructor, constructor, message,
-                             SKIP_NONE, no_caller,
+                             options, SKIP_NONE, no_caller,
                              ErrorUtils::StackTraceCollection::kNone)
            .ToHandle(&error)) {
     return MaybeHandle<Object>();

src/runtime/runtime-promise.cc

@@ -260,17 +260,18 @@ RUNTIME_FUNCTION(Runtime_ResolvePromise) {
 // takes care of the Error-related construction, e.g., stack traces.
 RUNTIME_FUNCTION(Runtime_ConstructAggregateErrorHelper) {
   HandleScope scope(isolate);
-  DCHECK_EQ(3, args.length());
+  DCHECK_EQ(4, args.length());
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, new_target, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, message, 2);
+  CONVERT_ARG_HANDLE_CHECKED(Object, options, 3);
 
   DCHECK_EQ(*target, *isolate->aggregate_error_function());
 
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
-      ErrorUtils::Construct(isolate, target, new_target, message));
+      ErrorUtils::Construct(isolate, target, new_target, message, options));
   return *result;
 }
 
@@ -299,6 +300,14 @@ RUNTIME_FUNCTION(Runtime_ConstructInternalAggregateErrorHelper) {
     arg2 = args.at<Object>(3);
   }
 
+  Handle<Object> options;
+  if (args.length() >= 5) {
+    CHECK(args[4].IsObject());
+    options = args.at<Object>(4);
+  } else {
+    options = isolate->factory()->undefined_value();
+  }
+
   Handle<Object> message_string = MessageFormatter::Format(
       isolate, MessageTemplate(message->value()), arg0, arg1, arg2);
 
@@ -306,8 +315,8 @@ RUNTIME_FUNCTION(Runtime_ConstructInternalAggregateErrorHelper) {
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       ErrorUtils::Construct(isolate, isolate->aggregate_error_function(),
-                            isolate->aggregate_error_function(),
-                            message_string));
+                            isolate->aggregate_error_function(), message_string,
+                            options));
   return *result;
 }
 

src/runtime/runtime.h

@@ -383,8 +383,8 @@ namespace internal {
   F(ResolvePromise, 2, 1)                \
   F(PromiseRejectAfterResolved, 2, 1)    \
   F(PromiseResolveAfterResolved, 2, 1)   \
-  F(ConstructAggregateErrorHelper, 3, 1) \
-  F(ConstructInternalAggregateErrorHelper, -1 /* <= 4*/, 1)
+  F(ConstructAggregateErrorHelper, 4, 1) \
+  F(ConstructInternalAggregateErrorHelper, -1 /* <= 5*/, 1)
 
 #define FOR_EACH_INTRINSIC_PROXY(F, I) \
   F(CheckProxyGetSetTrapResult, 2, 1)  \

test/mjsunit/harmony/error-cause.js

+// Copyright 2021 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.
+
+// Flags: --harmony-error-cause
+
+// Basic error
+(function () {
+  const err = Error('message', { cause: 'a cause' });
+  assertEquals('a cause', err.cause);
+  const descriptor = Object.getOwnPropertyDescriptor(err, 'cause');
+  assertEquals('a cause', descriptor.value);
+  assertFalse(descriptor.enumerable);
+  assertTrue(descriptor.writable);
+  assertTrue(descriptor.configurable);
+})();
+
+// No cause
+(function () {
+  const err = Error('message');
+  assertEquals(undefined, err.cause);
+})();
+
+// Chained errors
+(function () {
+  async function fail() { throw new Error('caused by fail') }
+
+  async function doJob() {
+    await fail()
+      .catch(err => {
+        throw new Error('Found an error', { cause: err });
+      });
+  }
+
+  async function main() {
+    try {
+      await doJob();
+    } catch (e) {
+      assertEquals('Found an error', e.message);
+      assertEquals('caused by fail', e.cause.message);
+    }
+  }
+
+  main();
+})();
+
+// AggregateError with cause
+(function() {
+  const err = AggregateError([1, 2, 3], 'aggregate errors', { cause: 'a cause' });
+  assertEquals('a cause', err.cause);
+  const descriptor = Object.getOwnPropertyDescriptor(err, 'cause');
+  assertEquals('a cause', descriptor.value);
+  assertFalse(descriptor.enumerable);
+  assertTrue(descriptor.writable);
+  assertTrue(descriptor.configurable);
+})();
+
+// Options is not an object
+(function () {
+  const err1 = Error('message', 42);
+  assertEquals(undefined, err1.cause);
+  const err2 = Error('message', null);
+  assertEquals(undefined, err2.cause);
+  const err3 = Error('message', [42]);
+  assertEquals(undefined, err3.cause);
+})();
+
+// Options object does not contain 'cause'
+(function () {
+  const err = Error('message', { syy: 'A finnish cause' });
+  assertEquals(undefined, err.cause);
+  assertEquals(undefined, err.syy);
+})();
+
+// Options is a proxy
+(function () {
+  const options = { cause: 'a cause' };
+  const proxy = new Proxy(options, { get: () => 'proxied cause'});
+  const err = Error('message', proxy);
+  assertEquals('proxied cause', err.cause);
+})();
+
+// Options is a proxy, but does not expose 'cause'
+(function () {
+  const options = { cause: 'a cause' };
+  const proxy = new Proxy(options, {
+    has: (_, key) => key != 'cause',
+    get: () => 'proxied cause'
+  })
+  const err = Error('message', proxy);
+  assertEquals(undefined, err.cause);
+})();
+
+// Options is a proxy, throw in 'get'
+(function () {
+  const options = { cause: 'a cause' };
+  const proxy = new Proxy(options, {
+    get: () => {  throw Error('proxy get', { cause: 'no reason' }) },
+  });
+  try {
+    Error('message', proxy);
+    assertUnreachable();
+  } catch(e) {
+    assertEquals('proxy get', e.message);
+    assertEquals('no reason', e.cause);
+  }
+})();
+
+// Options is a proxy, throw in 'has'
+(function () {
+  const options = { cause: 'a cause' };
+  const proxy = new Proxy(options, {
+    has: () => { throw Error('proxy has', { cause: 'no reason' }) },
+  });
+  try {
+    Error('message', proxy);
+    assertUnreachable();
+  } catch(e) {
+    assertEquals('proxy has', e.message);
+    assertEquals('no reason', e.cause);
+  }
+})();
+
+// Cause in the options prototype chain
+(function () {
+  function Options() {};
+  Options.prototype.cause = 'cause in the prototype';
+  const options = new Options();
+  const err = Error('message', options);
+  assertEquals('cause in the prototype', err.cause);
+})();
+
+// Cause in the options prototype chain proxy
+(function () {
+  function Options() {};
+  Options.prototype = new Proxy({ cause: 42 }, {
+    get: (_ ,name) => {
+      assertEquals('cause', name);
+      return 'cause in the prototype'
+  }});
+  const options = new Options();
+  const err = Error('message', options);
+  assertEquals('cause in the prototype', err.cause);
+})();
+
+// Cause in the options prototype chain proxy and throw
+(function () {
+  function Options() {};
+  Options.prototype = new Proxy({ cause: 42 }, { get: () => { throw Error('cause in the prototype')}  });
+  const options = new Options();
+  try {
+    Error('message', options);
+    assertUnreachable();
+  } catch(e) {
+    assertEquals('cause in the prototype', e.message);
+  }
+})();
+
+// Change Error.cause in the prototype
+(function () {
+  Error.prototype.cause = 'main cause';
+  const err1 = new Error('err1');
+  assertEquals('main cause', err1.cause);
+  const desc1 = Object.getOwnPropertyDescriptor(err1, 'cause');
+  assertEquals(undefined, desc1);
+
+  const err2 = new Error('err2', { cause: 'another cause' });
+  assertEquals(err2.cause, 'another cause');
+  const desc2 = Object.getOwnPropertyDescriptor(err2, 'cause');
+  assertFalse(desc2.enumerable);
+  assertTrue(desc2.writable);
+  assertTrue(desc2.configurable);
+
+  const err3 = new Error('err3');
+  err3.cause = 'after err3';
+  assertEquals('after err3', err3.cause);
+  const desc3 = Object.getOwnPropertyDescriptor(err3, 'cause');
+  assertTrue(desc3.enumerable);
+  assertTrue(desc3.writable);
+  assertTrue(desc3.configurable);
+})();
+
+// Change prototype to throw in setter
+(function() {
+  const my_proto = {};
+  Object.defineProperty(my_proto, 'cause', {set: function(x) { throw 'foo' } });
+  Error.prototype.__proto__ = my_proto
+  const err = Error('message', { cause: 'a cause' });
+  assertEquals('a cause', err.cause);
+})();
+
+// Use defineProperty to change Error cause and throw
+(function () {
+  Object.defineProperty(Error.prototype, 'cause', {
+    get: () => { throw Error('from get', { cause: 'inside get' }) },
+  });
+  const err1 = new Error('err1');
+  try {
+    err1.cause;
+    assertUnreachable();
+  } catch(e) {
+    assertEquals('from get', e.message);
+    assertEquals('inside get', e.cause);
+  }
+  const err2 = new Error('err2', { cause: 'another cause' });
+  assertEquals('another cause', err2.cause);
+})();
+
+// Serialize and deserialize error object
+(function () {
+  const err = Error('message', { cause: 'a cause' });
+  const worker = new Worker('onmessage = (msg) => postMessage(msg)', { type: 'string' });
+  worker.postMessage(err);
+  const serialized_err = worker.getMessage();
+  assertEquals(err, serialized_err);
+  const descriptor = Object.getOwnPropertyDescriptor(serialized_err, 'cause');
+  assertEquals(descriptor.value, 'a cause');
+  assertFalse(descriptor.enumerable);
+  assertTrue(descriptor.writable);
+  assertTrue(descriptor.configurable);
+})();

tools/v8heapconst.py

@@ -323,69 +323,69 @@ KNOWN_MAPS = {
   ("read_only_space", 0x03175): (67, "BasicBlockCountersMarkerMap"),
   ("read_only_space", 0x031b9): (87, "ArrayBoilerplateDescriptionMap"),
   ("read_only_space", 0x032b9): (100, "InterceptorInfoMap"),
-  ("read_only_space", 0x05401): (72, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x05429): (73, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x05451): (74, "CallableTaskMap"),
-  ("read_only_space", 0x05479): (75, "CallbackTaskMap"),
-  ("read_only_space", 0x054a1): (76, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x054c9): (79, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x054f1): (80, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x05519): (81, "AccessCheckInfoMap"),
-  ("read_only_space", 0x05541): (82, "AccessorInfoMap"),
-  ("read_only_space", 0x05569): (83, "AccessorPairMap"),
-  ("read_only_space", 0x05591): (84, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x055b9): (85, "AllocationMementoMap"),
-  ("read_only_space", 0x055e1): (88, "AsmWasmDataMap"),
-  ("read_only_space", 0x05609): (89, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x05631): (90, "BaselineDataMap"),
-  ("read_only_space", 0x05659): (91, "BreakPointMap"),
-  ("read_only_space", 0x05681): (92, "BreakPointInfoMap"),
-  ("read_only_space", 0x056a9): (93, "CachedTemplateObjectMap"),
-  ("read_only_space", 0x056d1): (95, "ClassPositionsMap"),
-  ("read_only_space", 0x056f9): (96, "DebugInfoMap"),
-  ("read_only_space", 0x05721): (99, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x05749): (101, "InterpreterDataMap"),
-  ("read_only_space", 0x05771): (102, "ModuleRequestMap"),
-  ("read_only_space", 0x05799): (103, "PromiseCapabilityMap"),
-  ("read_only_space", 0x057c1): (104, "PromiseReactionMap"),
-  ("read_only_space", 0x057e9): (105, "PropertyDescriptorObjectMap"),
-  ("read_only_space", 0x05811): (106, "PrototypeInfoMap"),
-  ("read_only_space", 0x05839): (107, "RegExpBoilerplateDescriptionMap"),
-  ("read_only_space", 0x05861): (108, "ScriptMap"),
-  ("read_only_space", 0x05889): (109, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x058b1): (110, "StackFrameInfoMap"),
-  ("read_only_space", 0x058d9): (111, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x05901): (112, "Tuple2Map"),
-  ("read_only_space", 0x05929): (113, "WasmExceptionTagMap"),
-  ("read_only_space", 0x05951): (114, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x05979): (115, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x059a1): (116, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x059c9): (134, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x059f1): (151, "DescriptorArrayMap"),
-  ("read_only_space", 0x05a19): (156, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x05a41): (155, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x05a69): (171, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x05a91): (168, "InternalClassMap"),
-  ("read_only_space", 0x05ab9): (178, "SmiPairMap"),
-  ("read_only_space", 0x05ae1): (177, "SmiBoxMap"),
-  ("read_only_space", 0x05b09): (145, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x05b31): (146, "ExportedSubClassMap"),
-  ("read_only_space", 0x05b59): (68, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x05b81): (69, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x05ba9): (133, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x05bd1): (169, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x05bf9): (147, "ExportedSubClass2Map"),
-  ("read_only_space", 0x05c21): (179, "SortStateMap"),
-  ("read_only_space", 0x05c49): (182, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x05c71): (86, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x05c99): (86, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x05cc1): (77, "LoadHandler1Map"),
-  ("read_only_space", 0x05ce9): (77, "LoadHandler2Map"),
-  ("read_only_space", 0x05d11): (77, "LoadHandler3Map"),
-  ("read_only_space", 0x05d39): (78, "StoreHandler0Map"),
-  ("read_only_space", 0x05d61): (78, "StoreHandler1Map"),
-  ("read_only_space", 0x05d89): (78, "StoreHandler2Map"),
-  ("read_only_space", 0x05db1): (78, "StoreHandler3Map"),
+  ("read_only_space", 0x05415): (72, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x0543d): (73, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05465): (74, "CallableTaskMap"),
+  ("read_only_space", 0x0548d): (75, "CallbackTaskMap"),
+  ("read_only_space", 0x054b5): (76, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x054dd): (79, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x05505): (80, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x0552d): (81, "AccessCheckInfoMap"),
+  ("read_only_space", 0x05555): (82, "AccessorInfoMap"),
+  ("read_only_space", 0x0557d): (83, "AccessorPairMap"),
+  ("read_only_space", 0x055a5): (84, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x055cd): (85, "AllocationMementoMap"),
+  ("read_only_space", 0x055f5): (88, "AsmWasmDataMap"),
+  ("read_only_space", 0x0561d): (89, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x05645): (90, "BaselineDataMap"),
+  ("read_only_space", 0x0566d): (91, "BreakPointMap"),
+  ("read_only_space", 0x05695): (92, "BreakPointInfoMap"),
+  ("read_only_space", 0x056bd): (93, "CachedTemplateObjectMap"),
+  ("read_only_space", 0x056e5): (95, "ClassPositionsMap"),
+  ("read_only_space", 0x0570d): (96, "DebugInfoMap"),
+  ("read_only_space", 0x05735): (99, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x0575d): (101, "InterpreterDataMap"),
+  ("read_only_space", 0x05785): (102, "ModuleRequestMap"),
+  ("read_only_space", 0x057ad): (103, "PromiseCapabilityMap"),
+  ("read_only_space", 0x057d5): (104, "PromiseReactionMap"),
+  ("read_only_space", 0x057fd): (105, "PropertyDescriptorObjectMap"),
+  ("read_only_space", 0x05825): (106, "PrototypeInfoMap"),
+  ("read_only_space", 0x0584d): (107, "RegExpBoilerplateDescriptionMap"),
+  ("read_only_space", 0x05875): (108, "ScriptMap"),
+  ("read_only_space", 0x0589d): (109, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x058c5): (110, "StackFrameInfoMap"),
+  ("read_only_space", 0x058ed): (111, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x05915): (112, "Tuple2Map"),
+  ("read_only_space", 0x0593d): (113, "WasmExceptionTagMap"),
+  ("read_only_space", 0x05965): (114, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x0598d): (115, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x059b5): (116, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x059dd): (134, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x05a05): (151, "DescriptorArrayMap"),
+  ("read_only_space", 0x05a2d): (156, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x05a55): (155, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x05a7d): (171, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x05aa5): (168, "InternalClassMap"),
+  ("read_only_space", 0x05acd): (178, "SmiPairMap"),
+  ("read_only_space", 0x05af5): (177, "SmiBoxMap"),
+  ("read_only_space", 0x05b1d): (145, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x05b45): (146, "ExportedSubClassMap"),
+  ("read_only_space", 0x05b6d): (68, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x05b95): (69, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x05bbd): (133, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x05be5): (169, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x05c0d): (147, "ExportedSubClass2Map"),
+  ("read_only_space", 0x05c35): (179, "SortStateMap"),
+  ("read_only_space", 0x05c5d): (182, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x05c85): (86, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x05cad): (86, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x05cd5): (77, "LoadHandler1Map"),
+  ("read_only_space", 0x05cfd): (77, "LoadHandler2Map"),
+  ("read_only_space", 0x05d25): (77, "LoadHandler3Map"),
+  ("read_only_space", 0x05d4d): (78, "StoreHandler0Map"),
+  ("read_only_space", 0x05d75): (78, "StoreHandler1Map"),
+  ("read_only_space", 0x05d9d): (78, "StoreHandler2Map"),
+  ("read_only_space", 0x05dc5): (78, "StoreHandler3Map"),
   ("map_space", 0x02119): (1057, "ExternalMap"),
   ("map_space", 0x02141): (1098, "JSMessageObjectMap"),
 }