Fix construction of simple objects with setters on prototype...

src/objects.cc

 // 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 7212 matching lines @@
 
   if (result <= static_cast<uint32_t>(Smi::kMaxValue)) {
     return Smi::FromInt(static_cast<int>(result));
   }
   ASSERT_NE(NULL, result_double);
   result_double->set_value(static_cast<double>(result));
   return result_double;
 }
 
 
+static bool CallbacksObjectHasSetter(Object* callbacks) {
+  if (!callbacks->IsFixedArray()) {
+    ASSERT(callbacks->IsAccessorInfo() || callbacks->IsProxy());
+    return true;
+  } else {
+    Object* setter = (FixedArray::cast(callbacks))->get(kSetterIndex);
+    if (setter->IsJSFunction()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+bool JSObject::HasSetter() {
+  for (Object* obj = this;
+       obj != Heap::null_value();
+       obj = JSObject::cast(obj)->GetPrototype()) {
+    JSObject* js_object = JSObject::cast(obj);
+    if (js_object->HasFastProperties()) {
+      DescriptorArray* descs = js_object->map()->instance_descriptors();
+      for (int i = 0; i < descs->number_of_descriptors(); i++) {
+        PropertyDetails details = descs->GetDetails(i);
+        if (details.type() == CALLBACKS) {
+          Object* callbacks = descs->GetCallbacksObject(i);
+          if (CallbacksObjectHasSetter(callbacks)) {
+            return true;
+          }
+        }
+      }
+    } else {
+      StringDictionary* dict = js_object->property_dictionary();
+      int capacity = dict->Capacity();
+      for (int i = 0; i < capacity; i++) {
+        Object* k = dict->KeyAt(i);
+        if (dict->IsKey(k)) {
+          PropertyType type = dict->DetailsAt(i).type();
+          ASSERT(type != FIELD);
+          if (type == CALLBACKS) {
+            Object* callbacks = dict->ValueAt(i);
+            if (CallbacksObjectHasSetter(callbacks)) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+
+
 Object* PixelArray::SetValue(uint32_t index, Object* value) {
   uint8_t clamped_value = 0;
   if (index < static_cast<uint32_t>(length())) {
     if (value->IsSmi()) {
       int int_value = Smi::cast(value)->value();
       if (int_value < 0) {
         clamped_value = 0;
       } else if (int_value > 255) {
         clamped_value = 255;
       } else {
@@ skipping 1099 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal