Clean up some uses of Failures and MaybeObjects.

src/accessors.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 55 matching lines @@
 template <class C>
 static C* FindInstanceOf(Isolate* isolate, Object* obj) {
   for (Object* cur = obj; !cur->IsNull(); cur = cur->GetPrototype(isolate)) {
     if (Is<C>(cur)) return C::cast(cur);
   }
   return NULL;
 }
 
 
 // Entry point that never should be called.
-MaybeObject* Accessors::IllegalSetter(Isolate* isolate,
-                                      JSObject*,
-                                      Object*,
-                                      void*) {
+Object* Accessors::IllegalSetter(Isolate* isolate,
+                                 JSObject*,
+                                 Object*,
+                                 void*) {
   UNREACHABLE();
   return NULL;
 }
 
 
 Object* Accessors::IllegalGetAccessor(Isolate* isolate,
                                       Object* object,
                                       void*) {
   UNREACHABLE();
   return object;
 }
 
 
-MaybeObject* Accessors::ReadOnlySetAccessor(Isolate* isolate,
-                                            JSObject*,
-                                            Object* value,
-                                            void*) {
+Object* Accessors::ReadOnlySetAccessor(Isolate* isolate,
+                                       JSObject*,
+                                       Object* value,
+                                       void*) {
   // According to ECMA-262, section 8.6.2.2, page 28, setting
   // read-only properties must be silently ignored.
   return value;
 }
 
 
 static V8_INLINE bool CheckForName(Handle<String> name,
                                    Handle<String> property_name,
                                    int offset,
                                    int* object_offset) {
@@ skipping 60 matching lines @@
 bool Accessors::IsJSObjectFieldAccessor<HeapType>(Handle<HeapType> type,
                                                   Handle<String> name,
                                                   int* object_offset);
 
 
 //
 // Accessors::ArrayLength
 //
 
 
-MaybeObject* Accessors::ArrayGetLength(Isolate* isolate,
-                                       Object* object,
-                                       void*) {
+Object* Accessors::ArrayGetLength(Isolate* isolate,
+                                  Object* object,
+                                  void*) {
   // Traverse the prototype chain until we reach an array.
   JSArray* holder = FindInstanceOf<JSArray>(isolate, object);
   return holder == NULL ? Smi::FromInt(0) : holder->length();
 }
 
 
 // The helper function will 'flatten' Number objects.
 Handle<Object> Accessors::FlattenNumber(Isolate* isolate,
                                         Handle<Object> value) {
   if (value->IsNumber() || !value->IsJSValue()) return value;
   Handle<JSValue> wrapper = Handle<JSValue>::cast(value);
   ASSERT(wrapper->GetIsolate()->context()->native_context()->number_function()->
       has_initial_map());
   if (wrapper->map() ==
       isolate->context()->native_context()->number_function()->initial_map()) {
     return handle(wrapper->value(), isolate);
   }
 
   return value;
 }
 
 
-MaybeObject* Accessors::ArraySetLength(Isolate* isolate,
-                                       JSObject* object_raw,
-                                       Object* value_raw,
-                                       void*) {
+Object* Accessors::ArraySetLength(Isolate* isolate,
+                                  JSObject* object_raw,
+                                  Object* value_raw,
+                                  void*) {
   HandleScope scope(isolate);
   Handle<JSObject> object(object_raw, isolate);
   Handle<Object> value(value_raw, isolate);
 
   // This means one of the object's prototypes is a JSArray and the
   // object does not have a 'length' property.  Calling SetProperty
   // causes an infinite loop.
   if (!object->IsJSArray()) {
     Handle<Object> result;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
@@ skipping 628 matching lines @@
 Handle<Object> Accessors::FunctionSetPrototype(Handle<JSFunction> function,
                                                Handle<Object> prototype) {
   ASSERT(function->should_have_prototype());
   Isolate* isolate = function->GetIsolate();
   Handle<Object> result;
   SetFunctionPrototype(isolate, function, prototype).ToHandle(&result);
   return result;
 }
 
 
-MaybeObject* Accessors::FunctionGetPrototype(Isolate* isolate,
-                                             Object* object,
-                                             void*) {
+Object* Accessors::FunctionGetPrototype(Isolate* isolate,
+                                        Object* object,
+                                        void*) {
   HandleScope scope(isolate);
   return *GetFunctionPrototype(isolate, Handle<Object>(object, isolate));
 }
 
 
-MaybeObject* Accessors::FunctionSetPrototype(Isolate* isolate,
-                                             JSObject* object,
-                                             Object* value,
-                                             void*) {
+Object* Accessors::FunctionSetPrototype(Isolate* isolate,
+                                        JSObject* object,
+                                        Object* value,
+                                        void*) {
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       SetFunctionPrototype(isolate,
                            Handle<JSObject>(object, isolate),
                            Handle<Object>(value, isolate)));
   return *result;
 }
 
 
 const AccessorDescriptor Accessors::FunctionPrototype = {
   FunctionGetPrototype,
   FunctionSetPrototype,
   0
 };
 
 
 //
 // Accessors::FunctionLength
 //
 
 
-MaybeObject* Accessors::FunctionGetLength(Isolate* isolate,
-                                          Object* object,
-                                          void*) {
+Object* Accessors::FunctionGetLength(Isolate* isolate,
+                                     Object* object,
+                                     void*) {
   JSFunction* function = FindInstanceOf<JSFunction>(isolate, object);
   if (function == NULL) return Smi::FromInt(0);
   // Check if already compiled.
   if (function->shared()->is_compiled()) {
     return Smi::FromInt(function->shared()->length());
   }
   // If the function isn't compiled yet, the length is not computed correctly
   // yet. Compile it now and return the right length.
   HandleScope scope(isolate);
   Handle<JSFunction> function_handle(function);
   if (Compiler::EnsureCompiled(function_handle, KEEP_EXCEPTION)) {
     return Smi::FromInt(function_handle->shared()->length());
   }
   return isolate->heap()->exception();
 }
 
 
 const AccessorDescriptor Accessors::FunctionLength = {
   FunctionGetLength,
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionName
 //
 
 
-MaybeObject* Accessors::FunctionGetName(Isolate* isolate,
-                                        Object* object,
-                                        void*) {
+Object* Accessors::FunctionGetName(Isolate* isolate,
+                                   Object* object,
+                                   void*) {
   JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
   return holder == NULL
       ? isolate->heap()->undefined_value()
       : holder->shared()->name();
 }
 
 
 const AccessorDescriptor Accessors::FunctionName = {
   FunctionGetName,
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionArguments
 //
 
 
 Handle<Object> Accessors::FunctionGetArguments(Handle<JSFunction> function) {
   CALL_HEAP_FUNCTION(function->GetIsolate(),
                      Accessors::FunctionGetArguments(function->GetIsolate(),
                                                      *function,
                                                      NULL),
                      Object);
 }
 
 
-static MaybeObject* ConstructArgumentsObjectForInlinedFunction(
+static Object* ConstructArgumentsObjectForInlinedFunction(
     JavaScriptFrame* frame,
     Handle<JSFunction> inlined_function,
     int inlined_frame_index) {
   Isolate* isolate = inlined_function->GetIsolate();
   Factory* factory = isolate->factory();
   SlotRefValueBuilder slot_refs(
       frame,
       inlined_frame_index,
       inlined_function->shared()->formal_parameter_count());
 
   int args_count = slot_refs.args_length();
   Handle<JSObject> arguments =
       factory->NewArgumentsObject(inlined_function, args_count);
   Handle<FixedArray> array = factory->NewFixedArray(args_count);
   slot_refs.Prepare(isolate);
   for (int i = 0; i < args_count; ++i) {
     Handle<Object> value = slot_refs.GetNext(isolate, 0);
     array->set(i, *value);
   }
   slot_refs.Finish(isolate);
   arguments->set_elements(*array);
 
   // Return the freshly allocated arguments object.
   return *arguments;
 }
 
 
-MaybeObject* Accessors::FunctionGetArguments(Isolate* isolate,
-                                             Object* object,
-                                             void*) {
+Object* Accessors::FunctionGetArguments(Isolate* isolate,
+                                        Object* object,
+                                        void*) {
   HandleScope scope(isolate);
   JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
   if (holder == NULL) return isolate->heap()->undefined_value();
   Handle<JSFunction> function(holder, isolate);
 
   if (function->shared()->native()) return isolate->heap()->null_value();
   // Find the top invocation of the function by traversing frames.
   List<JSFunction*> functions(2);
   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
@@ skipping 101 matching lines @@
     ASSERT(functions_.length() > 0);
     frame_iterator_.Advance();
     index_ = functions_.length() - 1;
   }
   JavaScriptFrameIterator frame_iterator_;
   List<JSFunction*> functions_;
   int index_;
 };
 
 
-MaybeObject* Accessors::FunctionGetCaller(Isolate* isolate,
-                                          Object* object,
-                                          void*) {
+Object* Accessors::FunctionGetCaller(Isolate* isolate,
+                                     Object* object,
+                                     void*) {
   HandleScope scope(isolate);
   DisallowHeapAllocation no_allocation;
   JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
   if (holder == NULL) return isolate->heap()->undefined_value();
   if (holder->shared()->native()) return isolate->heap()->null_value();
   Handle<JSFunction> function(holder, isolate);
 
   FrameFunctionIterator it(isolate, no_allocation);
 
   // Find the function from the frames.
@@ skipping 102 matching lines @@
   info->set_data(Smi::FromInt(index));
   Handle<Object> getter = v8::FromCData(isolate, &ModuleGetExport);
   Handle<Object> setter = v8::FromCData(isolate, &ModuleSetExport);
   info->set_getter(*getter);
   if (!(attributes & ReadOnly)) info->set_setter(*setter);
   return info;
 }
 
 
 } }  // namespace v8::internal