Make Failure inherit from MaybeObject instead of Object.

src/accessors.cc

 // Copyright 2006-2008 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 32 matching lines @@
   while (!Is<C>(obj)) {
     if (obj == Heap::null_value()) return NULL;
     obj = obj->GetPrototype();
   }
   *found_it = true;
   return C::cast(obj);
 }
 
 
 // Entry point that never should be called.
-Object* Accessors::IllegalSetter(JSObject*, Object*, void*) {
+MaybeObject* Accessors::IllegalSetter(JSObject*, Object*, void*) {
   UNREACHABLE();
   return NULL;
 }
 
 
 Object* Accessors::IllegalGetAccessor(Object* object, void*) {
   UNREACHABLE();
   return object;
 }
 
 
-Object* Accessors::ReadOnlySetAccessor(JSObject*, Object* value, void*) {
+MaybeObject* Accessors::ReadOnlySetAccessor(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;
 }
 
 
 //
 // Accessors::ArrayLength
 //
 
 
-Object* Accessors::ArrayGetLength(Object* object, void*) {
+MaybeObject* Accessors::ArrayGetLength(Object* object, void*) {
   // Traverse the prototype chain until we reach an array.
   bool found_it = false;
   JSArray* holder = FindInPrototypeChain<JSArray>(object, &found_it);
   if (!found_it) return Smi::FromInt(0);
   return holder->length();
 }
 
 
 // The helper function will 'flatten' Number objects.
 Object* Accessors::FlattenNumber(Object* value) {
   if (value->IsNumber() || !value->IsJSValue()) return value;
   JSValue* wrapper = JSValue::cast(value);
   ASSERT(
       Top::context()->global_context()->number_function()->has_initial_map());
   Map* number_map =
       Top::context()->global_context()->number_function()->initial_map();
   if (wrapper->map() == number_map) return wrapper->value();
   return value;
 }
 
 
-Object* Accessors::ArraySetLength(JSObject* object, Object* value, void*) {
+MaybeObject* Accessors::ArraySetLength(JSObject* object, Object* value, void*) {
   value = FlattenNumber(value);
 
   // Need to call methods that may trigger GC.
   HandleScope scope;
 
   // Protect raw pointers.
   Handle<JSObject> object_handle(object);
   Handle<Object> value_handle(value);
 
   bool has_exception;
@@ skipping 27 matching lines @@
   ArraySetLength,
   0
 };
 
 
 //
 // Accessors::StringLength
 //
 
 
-Object* Accessors::StringGetLength(Object* object, void*) {
+MaybeObject* Accessors::StringGetLength(Object* object, void*) {
   Object* value = object;
   if (object->IsJSValue()) value = JSValue::cast(object)->value();
   if (value->IsString()) return Smi::FromInt(String::cast(value)->length());
   // If object is not a string we return 0 to be compatible with WebKit.
   // Note: Firefox returns the length of ToString(object).
   return Smi::FromInt(0);
 }
 
 
 const AccessorDescriptor Accessors::StringLength = {
   StringGetLength,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptSource
 //
 
 
-Object* Accessors::ScriptGetSource(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetSource(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->source();
 }
 
 
 const AccessorDescriptor Accessors::ScriptSource = {
   ScriptGetSource,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptName
 //
 
 
-Object* Accessors::ScriptGetName(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetName(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->name();
 }
 
 
 const AccessorDescriptor Accessors::ScriptName = {
   ScriptGetName,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptId
 //
 
 
-Object* Accessors::ScriptGetId(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetId(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->id();
 }
 
 
 const AccessorDescriptor Accessors::ScriptId = {
   ScriptGetId,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptLineOffset
 //
 
 
-Object* Accessors::ScriptGetLineOffset(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetLineOffset(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->line_offset();
 }
 
 
 const AccessorDescriptor Accessors::ScriptLineOffset = {
   ScriptGetLineOffset,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptColumnOffset
 //
 
 
-Object* Accessors::ScriptGetColumnOffset(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetColumnOffset(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->column_offset();
 }
 
 
 const AccessorDescriptor Accessors::ScriptColumnOffset = {
   ScriptGetColumnOffset,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptData
 //
 
 
-Object* Accessors::ScriptGetData(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetData(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->data();
 }
 
 
 const AccessorDescriptor Accessors::ScriptData = {
   ScriptGetData,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptType
 //
 
 
-Object* Accessors::ScriptGetType(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetType(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->type();
 }
 
 
 const AccessorDescriptor Accessors::ScriptType = {
   ScriptGetType,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptCompilationType
 //
 
 
-Object* Accessors::ScriptGetCompilationType(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetCompilationType(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->compilation_type();
 }
 
 
 const AccessorDescriptor Accessors::ScriptCompilationType = {
   ScriptGetCompilationType,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptGetLineEnds
 //
 
 
-Object* Accessors::ScriptGetLineEnds(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetLineEnds(Object* object, void*) {
   HandleScope scope;
   Handle<Script> script(Script::cast(JSValue::cast(object)->value()));
   InitScriptLineEnds(script);
   ASSERT(script->line_ends()->IsFixedArray());
   Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
   Handle<FixedArray> copy = Factory::CopyFixedArray(line_ends);
   Handle<JSArray> js_array = Factory::NewJSArrayWithElements(copy);
   return *js_array;
 }
 
 
 const AccessorDescriptor Accessors::ScriptLineEnds = {
   ScriptGetLineEnds,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptGetContextData
 //
 
 
-Object* Accessors::ScriptGetContextData(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetContextData(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   return Script::cast(script)->context_data();
 }
 
 
 const AccessorDescriptor Accessors::ScriptContextData = {
   ScriptGetContextData,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptGetEvalFromScript
 //
 
 
-Object* Accessors::ScriptGetEvalFromScript(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetEvalFromScript(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   if (!Script::cast(script)->eval_from_shared()->IsUndefined()) {
     Handle<SharedFunctionInfo> eval_from_shared(
         SharedFunctionInfo::cast(Script::cast(script)->eval_from_shared()));
 
     if (eval_from_shared->script()->IsScript()) {
       Handle<Script> eval_from_script(Script::cast(eval_from_shared->script()));
       return *GetScriptWrapper(eval_from_script);
     }
   }
   return Heap::undefined_value();
 }
 
 
 const AccessorDescriptor Accessors::ScriptEvalFromScript = {
   ScriptGetEvalFromScript,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptGetEvalFromScriptPosition
 //
 
 
-Object* Accessors::ScriptGetEvalFromScriptPosition(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetEvalFromScriptPosition(Object* object, void*) {
   HandleScope scope;
   Handle<Script> script(Script::cast(JSValue::cast(object)->value()));
 
   // If this is not a script compiled through eval there is no eval position.
   int compilation_type = Smi::cast(script->compilation_type())->value();
   if (compilation_type != Script::COMPILATION_TYPE_EVAL) {
     return Heap::undefined_value();
   }
 
   // Get the function from where eval was called and find the source position
@@ skipping 10 matching lines @@
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::ScriptGetEvalFromFunctionName
 //
 
 
-Object* Accessors::ScriptGetEvalFromFunctionName(Object* object, void*) {
+MaybeObject* Accessors::ScriptGetEvalFromFunctionName(Object* object, void*) {
   Object* script = JSValue::cast(object)->value();
   Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(
       Script::cast(script)->eval_from_shared()));
 
 
   // Find the name of the function calling eval.
   if (!shared->name()->IsUndefined()) {
     return shared->name();
   } else {
     return shared->inferred_name();
   }
 }
 
 
 const AccessorDescriptor Accessors::ScriptEvalFromFunctionName = {
   ScriptGetEvalFromFunctionName,
   IllegalSetter,
   0
 };
 
 
 //
 // Accessors::FunctionPrototype
 //
 
 
-Object* Accessors::FunctionGetPrototype(Object* object, void*) {
+MaybeObject* Accessors::FunctionGetPrototype(Object* object, void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   if (!function->has_prototype()) {
-    Object* prototype = Heap::AllocateFunctionPrototype(function);
-    if (prototype->IsFailure()) return prototype;
-    Object* result = function->SetPrototype(prototype);
-    if (result->IsFailure()) return result;
+    Object* prototype;
+    { MaybeObject* maybe_prototype = Heap::AllocateFunctionPrototype(function);
+      if (!maybe_prototype->ToObject(&prototype)) return maybe_prototype;
+    }
+    Object* result;
+    { MaybeObject* maybe_result = function->SetPrototype(prototype);
+      if (!maybe_result->ToObject(&result)) return maybe_result;
+    }
   }
   return function->prototype();
 }
 
 
-Object* Accessors::FunctionSetPrototype(JSObject* object,
-                                        Object* value,
-                                        void*) {
+MaybeObject* Accessors::FunctionSetPrototype(JSObject* object,
+                                             Object* value,
+                                             void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   if (function->has_initial_map()) {
     // If the function has allocated the initial map
     // replace it with a copy containing the new prototype.
-    Object* new_map = function->initial_map()->CopyDropTransitions();
-    if (new_map->IsFailure()) return new_map;
+    Object* new_map;
+    { MaybeObject* maybe_new_map =
+          function->initial_map()->CopyDropTransitions();
+      if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map;
+    }
     function->set_initial_map(Map::cast(new_map));
   }
-  Object* prototype = function->SetPrototype(value);
-  if (prototype->IsFailure()) return prototype;
+  Object* prototype;
+  { MaybeObject* maybe_prototype = function->SetPrototype(value);
+    if (!maybe_prototype->ToObject(&prototype)) return maybe_prototype;
+  }
   ASSERT(function->prototype() == value);
   return function;
 }
 
 
 const AccessorDescriptor Accessors::FunctionPrototype = {
   FunctionGetPrototype,
   FunctionSetPrototype,
   0
 };
 
 
 //
 // Accessors::FunctionLength
 //
 
 
-Object* Accessors::FunctionGetLength(Object* object, void*) {
+MaybeObject* Accessors::FunctionGetLength(Object* object, void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Smi::FromInt(0);
   // Check if already compiled.
   if (!function->shared()->is_compiled()) {
     // If the function isn't compiled yet, the length is not computed
     // correctly yet. Compile it now and return the right length.
     HandleScope scope;
     Handle<SharedFunctionInfo> shared(function->shared());
     if (!CompileLazyShared(shared, KEEP_EXCEPTION)) {
@@ skipping 11 matching lines @@
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionName
 //
 
 
-Object* Accessors::FunctionGetName(Object* object, void*) {
+MaybeObject* Accessors::FunctionGetName(Object* object, void*) {
   bool found_it = false;
   JSFunction* holder = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   return holder->shared()->name();
 }
 
 
 const AccessorDescriptor Accessors::FunctionName = {
   FunctionGetName,
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionArguments
 //
 
 
-Object* Accessors::FunctionGetArguments(Object* object, void*) {
+MaybeObject* Accessors::FunctionGetArguments(Object* object, void*) {
   HandleScope scope;
   bool found_it = false;
   JSFunction* holder = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   Handle<JSFunction> function(holder);
 
   // Find the top invocation of the function by traversing frames.
   for (JavaScriptFrameIterator it; !it.done(); it.Advance()) {
     // Skip all frames that aren't invocations of the given function.
     JavaScriptFrame* frame = it.frame();
@@ skipping 38 matching lines @@
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionCaller
 //
 
 
-Object* Accessors::FunctionGetCaller(Object* object, void*) {
+MaybeObject* Accessors::FunctionGetCaller(Object* object, void*) {
   HandleScope scope;
+  AssertNoAllocation no_alloc;
   bool found_it = false;
   JSFunction* holder = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   Handle<JSFunction> function(holder);
 
   // Find the top invocation of the function by traversing frames.
   for (JavaScriptFrameIterator it; !it.done(); it.Advance()) {
     // Skip all frames that aren't invocations of the given function.
     if (it.frame()->function() != *function) continue;
     // Once we have found the frame, we need to go to the caller
@@ skipping 17 matching lines @@
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::ObjectPrototype
 //
 
 
-Object* Accessors::ObjectGetPrototype(Object* receiver, void*) {
+MaybeObject* Accessors::ObjectGetPrototype(Object* receiver, void*) {
   Object* current = receiver->GetPrototype();
   while (current->IsJSObject() &&
          JSObject::cast(current)->map()->is_hidden_prototype()) {
     current = current->GetPrototype();
   }
   return current;
 }
 
 
-Object* Accessors::ObjectSetPrototype(JSObject* receiver,
-                                      Object* value,
-                                      void*) {
+MaybeObject* Accessors::ObjectSetPrototype(JSObject* receiver,
+                                           Object* value,
+                                           void*) {
   const bool skip_hidden_prototypes = true;
   // To be consistent with other Set functions, return the value.
   return receiver->SetPrototype(value, skip_hidden_prototypes);
 }
 
 
 const AccessorDescriptor Accessors::ObjectPrototype = {
   ObjectGetPrototype,
   ObjectSetPrototype,
   0
 };
 
 } }  // namespace v8::internal