Return MaybeHandle from Invoke.

src/factory.cc

 // Copyright 2014 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 "factory.h"
 
 #include "isolate-inl.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1140 matching lines @@
   // constructor may not have been defined.  Bail out.
   if (!fun_obj->IsJSFunction()) {
     return EmergencyNewError(message, args);
   }
   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
   Handle<Object> message_obj = InternalizeUtf8String(message);
   Handle<Object> argv[] = { message_obj, args };
 
   // Invoke the JavaScript factory method. If an exception is thrown while
   // running the factory method, use the exception as the result.
-  bool caught_exception;
+  bool caught_exception = false;
   Handle<Object> result = Execution::TryCall(fun,
                                              isolate()->js_builtins_object(),
                                              ARRAY_SIZE(argv),
                                              argv,
                                              &caught_exception);
+  if (caught_exception) {
+    return Handle<Object>(isolate()->pending_exception(), isolate());

[Igor Sheludko, 2014/04/10 21:44:35]

I think we should return result here as well, because according to the
ASSERT(!isolate->has_pending_exception()); at the end of TryCall() there would
be no exception in the isolate. Please add a comment here about that.

+  }
   return result;
 }
 
 
 Handle<Object> Factory::NewError(Handle<String> message) {
   return NewError("$Error", message);
 }
 
 
 Handle<Object> Factory::NewError(const char* constructor,
                                  Handle<String> message) {
   Handle<String> constr = InternalizeUtf8String(constructor);
   Handle<JSFunction> fun = Handle<JSFunction>::cast(
       GlobalObject::GetPropertyNoExceptionThrown(
           isolate()->js_builtins_object(), constr));
   Handle<Object> argv[] = { message };
 
   // Invoke the JavaScript factory method. If an exception is thrown while
   // running the factory method, use the exception as the result.
-  bool caught_exception;
+  bool caught_exception = false;
   Handle<Object> result = Execution::TryCall(fun,
                                              isolate()->js_builtins_object(),
                                              ARRAY_SIZE(argv),
                                              argv,
                                              &caught_exception);
+  if (caught_exception) {
+    return Handle<Object>(isolate()->pending_exception(), isolate());
+  }
   return result;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         InstanceType type,
                                         int instance_size,
                                         Handle<Code> code,
                                         bool force_initial_map) {
   // Allocate the function
@@ skipping 782 matching lines @@
   store->set(JSRegExp::kIrregexpASCIICodeSavedIndex, uninitialized);
   store->set(JSRegExp::kIrregexpUC16CodeSavedIndex, uninitialized);
   store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
   store->set(JSRegExp::kIrregexpCaptureCountIndex,
              Smi::FromInt(capture_count));
   regexp->set_data(*store);
 }
 
 
 
-void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc,
-                                Handle<JSObject> instance,
-                                bool* pending_exception) {
+MaybeHandle<FunctionTemplateInfo> Factory::ConfigureInstance(
+    Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance) {
   // Configure the instance by adding the properties specified by the
   // instance template.
   Handle<Object> instance_template(desc->instance_template(), isolate());
-  if (!instance_template->IsUndefined()) {
-    Execution::ConfigureInstance(isolate(),
-                                 instance,
-                                 instance_template,
-                                 pending_exception);
-  } else {
-    *pending_exception = false;
+  if (instance_template->IsUndefined() ||
+      !Execution::ConfigureInstance(
+          isolate(), instance, instance_template).is_null()) {
+    return desc;
   }
+  return MaybeHandle<FunctionTemplateInfo>();
 }
 
 
 Handle<Object> Factory::GlobalConstantFor(Handle<String> name) {
   Heap* h = isolate()->heap();
   if (name->Equals(h->undefined_string())) return undefined_value();
   if (name->Equals(h->nan_string())) return nan_value();
   if (name->Equals(h->infinity_string())) return infinity_value();
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 } }  // namespace v8::internal