This is a little experiment to move Failure to a superclass above Object...

src/objects.h

 // Copyright 2006-2009 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 567 matching lines @@
   Object* ptr;
   const char* str;
   double number;
 };
 
 
 // A template-ized version of the IsXXX functions.
 template <class C> static inline bool Is(Object* obj);
 
 
+class Object;
+
+
+class TryAllocation BASE_EMBEDDED {
+ public:
+  inline bool ToObject(Object** out) {
+    if (this->IsFailure()) return false;
+    *out = Object::cast(this);
+    return true;
+  }
+};
+
+
 // Object is the abstract superclass for all classes in the
 // object hierarchy.
 // Object does not use any virtual functions to avoid the
 // allocation of the C++ vtable.
 // Since Smi and Failure are subclasses of Object no
 // data members can be present in Object.
-class Object BASE_EMBEDDED {
+class Object : public TryAllocation {
  public:
   // Type testing.
   inline bool IsSmi();
   inline bool IsHeapObject();
   inline bool IsHeapNumber();
   inline bool IsString();
   inline bool IsSymbol();
   // See objects-inl.h for more details
   inline bool IsSeqString();
   inline bool IsExternalString();
   inline bool IsExternalTwoByteString();
   inline bool IsExternalAsciiString();
   inline bool IsSeqTwoByteString();
   inline bool IsSeqAsciiString();
   inline bool IsConsString();
 
   inline bool IsNumber();
   inline bool IsByteArray();
   inline bool IsPixelArray();
   inline bool IsExternalArray();
   inline bool IsExternalByteArray();
   inline bool IsExternalUnsignedByteArray();
   inline bool IsExternalShortArray();
   inline bool IsExternalUnsignedShortArray();
   inline bool IsExternalIntArray();
   inline bool IsExternalUnsignedIntArray();
   inline bool IsExternalFloatArray();
-  inline bool IsFailure();
   inline bool IsRetryAfterGC();
   inline bool IsOutOfMemoryFailure();
   inline bool IsException();
   inline bool IsJSObject();
   inline bool IsJSContextExtensionObject();
   inline bool IsMap();
   inline bool IsFixedArray();
   inline bool IsDescriptorArray();
   inline bool IsContext();
   inline bool IsCatchContext();
@@ skipping 180 matching lines @@
 //
 // The remaining bits is the size of the allocation request in units
 // of the pointer size, and is zeroed except for RETRY_AFTER_GC
 // failures.  The 25 bits (on a 32 bit platform) gives a representable
 // range of 2^27 bytes (128MB).
 
 // Failure type tag info.
 const int kFailureTypeTagSize = 2;
 const int kFailureTypeTagMask = (1 << kFailureTypeTagSize) - 1;
 
-class Failure: public Object {
+class Failure: public TryAllocation {
  public:
   // RuntimeStubs assumes EXCEPTION = 1 in the compiler-generated code.
   enum Type {
     RETRY_AFTER_GC = 0,
     EXCEPTION = 1,       // Returning this marker tells the real exception
                          // is in Top::pending_exception.
     INTERNAL_ERROR = 2,
     OUT_OF_MEMORY_EXCEPTION = 3
   };
 
@@ skipping 441 matching lines @@
   inline NumberDictionary* element_dictionary();  // Gets slow elements.
   // Requires: this->HasFastElements().
   inline Object* EnsureWritableFastElements();
 
   // Collects elements starting at index 0.
   // Undefined values are placed after non-undefined values.
   // Returns the number of non-undefined values.
   Object* PrepareElementsForSort(uint32_t limit);
   // As PrepareElementsForSort, but only on objects where elements is
   // a dictionary, and it will stay a dictionary.
-  MUST_USE_RESULT Object* PrepareSlowElementsForSort(uint32_t limit);
+  TryAllocation* PrepareSlowElementsForSort(uint32_t limit);
 
   Object* SetProperty(String* key,
                       Object* value,
                       PropertyAttributes attributes);
   Object* SetProperty(LookupResult* result,
                       String* key,
                       Object* value,
                       PropertyAttributes attributes);
   Object* SetPropertyWithFailedAccessCheck(LookupResult* result,
                                            String* name,
@@ skipping 4423 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_