Make integer indexed properties ("elements") work for proxies.

src/objects.cc

 // Copyright 2011 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 216 matching lines @@
   Handle<Object> result = CallTrap(
     "get", isolate->derived_get_trap(), ARRAY_SIZE(args), args);
   if (isolate->has_pending_exception()) return Failure::Exception();
 
   return *result;
 }
 
 
 MaybeObject* JSProxy::GetElementWithHandler(Object* receiver,
                                             uint32_t index) {
-  Heap* heap = GetHeap();
-  Object* number;
-  MaybeObject* maybe = heap->NumberFromUint32(index);
-  if (!maybe->To<Object>(&number)) return maybe;
-  maybe = heap->NumberToString(number);
   String* name;
+  MaybeObject* maybe = GetHeap()->Uint32ToString(index);
   if (!maybe->To<String>(&name)) return maybe;
   return GetPropertyWithHandler(receiver, name);
 }
 
 
+MaybeObject* JSProxy::SetElementWithHandler(uint32_t index,
+                                            Object* value,
+                                            StrictModeFlag strict_mode) {
+  String* name;
+  MaybeObject* maybe = GetHeap()->Uint32ToString(index);
+  if (!maybe->To<String>(&name)) return maybe;
+  return SetPropertyWithHandler(name, value, NONE, strict_mode);
+}
+
+
+bool JSProxy::HasElementWithHandler(uint32_t index) {
+  String* name;
+  MaybeObject* maybe = GetHeap()->Uint32ToString(index);
+  if (!maybe->To<String>(&name)) return maybe;
+  return HasPropertyWithHandler(name);
+}
+
+
 MaybeObject* Object::GetPropertyWithDefinedGetter(Object* receiver,
                                                   JSFunction* getter) {
   HandleScope scope;
   Handle<JSFunction> fun(JSFunction::cast(getter));
   Handle<Object> self(receiver);
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debug* debug = fun->GetHeap()->isolate()->debug();
   // Handle stepping into a getter if step into is active.
   if (debug->StepInActive()) {
     debug->HandleStepIn(fun, Handle<Object>::null(), 0, false);
@@ skipping 1661 matching lines @@
 
 MaybeObject* JSObject::SetElementWithCallbackSetterInPrototypes(
     uint32_t index,
     Object* value,
     bool* found,
     StrictModeFlag strict_mode) {
   Heap* heap = GetHeap();
   for (Object* pt = GetPrototype();
        pt != heap->null_value();
        pt = pt->GetPrototype()) {
+    if (pt->IsJSProxy()) {
+      String* name;
+      MaybeObject* maybe = GetHeap()->Uint32ToString(index);
+      if (!maybe->To<String>(&name)) {
+        *found = true;  // Force abort
+        return maybe;
+      }
+      return JSProxy::cast(pt)->SetPropertyWithHandlerDefiningSetter(
+          name, value, NONE, strict_mode, found);
+    }
     if (!JSObject::cast(pt)->HasDictionaryElements()) {
       continue;
     }
     NumberDictionary* dictionary = JSObject::cast(pt)->element_dictionary();
     int entry = dictionary->FindEntry(index);
     if (entry != NumberDictionary::kNotFound) {
       PropertyDetails details = dictionary->DetailsAt(entry);
       if (details.type() == CALLBACKS) {
         *found = true;
         return SetElementWithCallback(dictionary->ValueAt(entry),
@@ skipping 315 matching lines @@
   Handle<Object> value(value_raw);
 
   Handle<Object> args[] = { receiver, name, value };
   CallTrap("set", isolate->derived_set_trap(), ARRAY_SIZE(args), args);
   if (isolate->has_pending_exception()) return Failure::Exception();
 
   return *value;
 }
 
 
+MUST_USE_RESULT MaybeObject* JSProxy::SetPropertyWithHandlerDefiningSetter(
+    String* name,
+    Object* value,
+    PropertyAttributes attributes,
+    StrictModeFlag strict_mode,
+    bool* found) {
+  *found = true;  // except where defined otherwise...
+  Isolate* isolate = GetHeap()->isolate();
+  Handle<JSProxy> proxy(this);
+  Handle<String> hname(name);
+  Handle<Object> hvalue(value);
+  Handle<Object> args[] = { hname };
+  Handle<Object> result = proxy->CallTrap(
+    "getOwnPropertyDescriptor", Handle<Object>(), ARRAY_SIZE(args), args);

[Rico, 2011/09/12 11:21:18]

4 space indention 

[rossberg, 2011/09/13 16:10:25]

Done.

+  if (isolate->has_pending_exception()) return Failure::Exception();
+
+  if (!result->IsUndefined()) {
+    // The proxy handler cares about this property.
+    // Check whether it is virtualized as an accessor.
+    Handle<String> getter_name =

[Rico, 2011/09/12 11:21:18]

We might as well lookup the setter first, and then only lookup the getter if the
setter is not found

[rossberg, 2011/09/13 16:10:25]

Done.

I also forgot to invoke ToCompletePropertyDescriptor, as the Proxy spec
requires.

+        isolate->factory()->LookupAsciiSymbol("get");
+    Handle<Object> getter(
+        v8::internal::GetProperty(result, getter_name));
+    if (isolate->has_pending_exception()) return Failure::Exception();
+    Handle<String> setter_name =
+        isolate->factory()->LookupAsciiSymbol("set");
+    Handle<Object> setter(
+        v8::internal::GetProperty(result, setter_name));
+    if (isolate->has_pending_exception()) return Failure::Exception();
+
+    if (!setter->IsUndefined()) {
+      // We have a setter -- invoke it.
+      if (setter->IsJSFunction()) {
+        return proxy->SetPropertyWithDefinedSetter(
+            JSFunction::cast(*setter), *hvalue);
+      }
+      Handle<Object> args[] = { setter };
+      Handle<Object> error = isolate->factory()->NewTypeError(
+         "setter_must_be_callable", HandleVector(args, ARRAY_SIZE(args)));

[Rico, 2011/09/12 11:21:18]

4 space indention

[rossberg, 2011/09/13 16:10:25]

Done.

+      return isolate->Throw(*error);
+    } else if (!getter->IsUndefined()) {
+      // We have a getter but no setter -- the property may not be
+      // written. In strict mode, throw an error.
+      if (strict_mode == kNonStrictMode) return *hvalue;
+      Handle<Object> args[] = { hname, proxy };
+      Handle<Object> error = isolate->factory()->NewTypeError(
+          "no_setter_in_callback", HandleVector(args, ARRAY_SIZE(args)));
+      return isolate->Throw(*error);
+    }
+    // Fall-through.
+  }
+
+  // The proxy does not define the property as an accessor.
+  *found = false;
+  return value;
+}
+
+
 MUST_USE_RESULT MaybeObject* JSProxy::DeletePropertyWithHandler(
     String* name_raw, DeleteMode mode) {
   Isolate* isolate = GetIsolate();
   HandleScope scope(isolate);
   Handle<Object> receiver(this);
   Handle<Object> name(name_raw);
 
   Handle<Object> args[] = { name };
   Handle<Object> result = CallTrap(
     "delete", Handle<Object>(), ARRAY_SIZE(args), args);
   if (isolate->has_pending_exception()) return Failure::Exception();
 
   Object* bool_result = result->ToBoolean();
   if (mode == STRICT_DELETION && bool_result == GetHeap()->false_value()) {
     Handle<String> trap_name = isolate->factory()->LookupAsciiSymbol("delete");
     Handle<Object> args[] = { Handle<Object>(handler()), trap_name };
     Handle<Object> error = isolate->factory()->NewTypeError(
         "handler_failed", HandleVector(args, ARRAY_SIZE(args)));
     isolate->Throw(*error);
     return Failure::Exception();
   }
   return bool_result;
 }
 
 
+MUST_USE_RESULT MaybeObject* JSProxy::DeleteElementWithHandler(
+    uint32_t index, DeleteMode mode) {

[Rico, 2011/09/12 11:21:18]

parameters on separate lines to be consistent

[rossberg, 2011/09/13 16:10:25]

Done.

+  String* name;
+  MaybeObject* maybe = GetHeap()->Uint32ToString(index);
+  if (!maybe->To<String>(&name)) return maybe;
+  return JSProxy::DeletePropertyWithHandler(name, mode);
+}
+
+
 MUST_USE_RESULT PropertyAttributes JSProxy::GetPropertyAttributeWithHandler(
     JSReceiver* receiver_raw,
     String* name_raw) {
   Isolate* isolate = GetIsolate();
   HandleScope scope(isolate);
   Handle<JSReceiver> receiver(receiver_raw);
   Handle<Object> name(name_raw);
 
   Handle<Object> args[] = { name };
   Handle<Object> result = CallTrap(
@@ skipping 21 matching lines @@
   if (isolate->has_pending_exception()) return NONE;
 
   int attributes = NONE;
   if (enumerable->ToBoolean()->IsFalse()) attributes |= DONT_ENUM;
   if (configurable->ToBoolean()->IsFalse()) attributes |= DONT_DELETE;
   if (writable->ToBoolean()->IsFalse()) attributes |= READ_ONLY;
   return static_cast<PropertyAttributes>(attributes);
 }
 
 
+MUST_USE_RESULT PropertyAttributes JSProxy::GetElementAttributeWithHandler(
+    JSReceiver* receiver,
+    uint32_t index) {
+  String* name;
+  MaybeObject* maybe = GetHeap()->Uint32ToString(index);
+  if (!maybe->To<String>(&name)) return NONE;

[Rico, 2011/09/12 11:21:18]

Why do we return NONE here if allocation fails?

[rossberg, 2011/09/13 16:10:25]

Fixed by introducing a factory method.

+  return GetPropertyAttributeWithHandler(receiver, name);
+}
+
+
 void JSProxy::Fix() {
   Isolate* isolate = GetIsolate();
   HandleScope scope(isolate);
   Handle<JSProxy> self(this);
 
   if (IsJSFunctionProxy()) {
     isolate->factory()->BecomeJSFunction(self);
     // Code will be set on the JavaScript side.
   } else {
     isolate->factory()->BecomeJSObject(self);
@@ skipping 77 matching lines @@
     if (accessor_result.IsFound()) {
       if (accessor_result.type() == CALLBACKS) {
         return SetPropertyWithCallback(accessor_result.GetCallbackObject(),
                                        name,
                                        value,
                                        accessor_result.holder(),
                                        strict_mode);
       } else if (accessor_result.type() == HANDLER) {
         // There is a proxy in the prototype chain. Invoke its
         // getOwnPropertyDescriptor trap.
+        bool found = false;
+        Handle<JSObject> self(this);
+        Handle<String> hname(name);
+        Handle<Object> hvalue(value);
+        MaybeObject* result =
+            accessor_result.proxy()->SetPropertyWithHandlerDefiningSetter(
+                name, value, attributes, strict_mode, &found);
+        if (found) return result;
+        // The proxy does not define the property as an accessor.
+        // Consequently, it has no effect on setting the receiver.
+        return self->AddProperty(*hname, *hvalue, attributes, strict_mode);
+/*

[Rico, 2011/09/12 11:21:18]

If this code is not needed anymore please delete it

[rossberg, 2011/09/13 16:10:25]

Oops.

         Isolate* isolate = heap->isolate();
         Handle<JSObject> self(this);
         Handle<String> hname(name);
         Handle<Object> hvalue(value);
         Handle<JSProxy> proxy(accessor_result.proxy());
         Handle<Object> args[] = { hname };
         Handle<Object> result = proxy->CallTrap(
           "getOwnPropertyDescriptor", Handle<Object>(), ARRAY_SIZE(args), args);
         if (isolate->has_pending_exception()) return Failure::Exception();
 
@@ skipping 27 matching lines @@
             if (strict_mode == kNonStrictMode) return *hvalue;
             Handle<Object> args[] = { hname, proxy };
             Handle<Object> error = isolate->factory()->NewTypeError(
                 "no_setter_in_callback", HandleVector(args, ARRAY_SIZE(args)));
             return isolate->Throw(*error);
           }
           // The proxy does not define the property as an accessor.
           // Consequently, it has no effect on setting the receiver.
           return self->AddProperty(*hname, *hvalue, attributes, strict_mode);
         }
+*/
       }
     }
   }
 
   // At this point, no GC should have happened, as this would invalidate
   // 'result', which we cannot handlify!
 
   if (!result->IsFound()) {
     // Neither properties nor transitions found.
     return AddProperty(name, value, attributes, strict_mode);
@@ skipping 226 matching lines @@
                                                             *name_handle,
                                                             continue_search);
 }
 
 
 PropertyAttributes JSReceiver::GetPropertyAttributeWithReceiver(
       JSReceiver* receiver,
       String* key) {
   uint32_t index = 0;
   if (IsJSObject() && key->AsArrayIndex(&index)) {
-    if (JSObject::cast(this)->HasElementWithReceiver(receiver, index))
-      return NONE;
-    return ABSENT;
+    return JSObject::cast(this)->HasElementWithReceiver(receiver, index)
+        ? NONE : ABSENT;
   }
   // Named property.
   LookupResult result;
   Lookup(key, &result);
   return GetPropertyAttribute(receiver, &result, key, true);
 }
 
 
 PropertyAttributes JSReceiver::GetPropertyAttribute(JSReceiver* receiver,
                                                     LookupResult* result,
@@ skipping 512 matching lines @@
     mode = JSReceiver::FORCE_DELETION;
   }
 
   return GetElementsAccessor()->Delete(this, index, mode);
 }
 
 
 MaybeObject* JSReceiver::DeleteProperty(String* name, DeleteMode mode) {
   if (IsJSProxy()) {
     return JSProxy::cast(this)->DeletePropertyWithHandler(name, mode);
-  } else {
-    return JSObject::cast(this)->DeleteProperty(name, mode);
   }
+  return JSObject::cast(this)->DeleteProperty(name, mode);
 }
 
 
+MaybeObject* JSReceiver::DeleteElement(uint32_t index, DeleteMode mode) {
+  if (IsJSProxy()) {
+    return JSProxy::cast(this)->DeleteElementWithHandler(index, mode);
+  }
+  return JSObject::cast(this)->DeleteElement(index, mode);
+}
+
+
 MaybeObject* JSObject::DeleteProperty(String* name, DeleteMode mode) {
   Isolate* isolate = GetIsolate();
   // ECMA-262, 3rd, 8.6.2.5
   ASSERT(name->IsString());
 
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !isolate->MayNamedAccess(this, name, v8::ACCESS_DELETE)) {
     isolate->ReportFailedAccessCheck(this, v8::ACCESS_DELETE);
     return isolate->heap()->false_value();
@@ skipping 4609 matching lines @@
     case NON_STRICT_ARGUMENTS_ELEMENTS:
       UNREACHABLE();
       break;
   }
 
   // Handle [] on String objects.
   if (this->IsStringObjectWithCharacterAt(index)) return true;
 
   Object* pt = GetPrototype();
   if (pt->IsNull()) return false;
+  if (pt->IsJSProxy()) {
+    // We need to follow the spec and simulate a call to [[GetOwnProperty]].
+    return JSProxy::cast(pt)->GetElementAttributeWithHandler(
+        receiver, index) != ABSENT;
+  }
   return JSObject::cast(pt)->HasElementWithReceiver(receiver, index);
 }
 
 
 bool JSObject::HasElementWithInterceptor(JSReceiver* receiver, uint32_t index) {
   Isolate* isolate = GetIsolate();
   // Make sure that the top context does not change when doing
   // callbacks or interceptor calls.
   AssertNoContextChange ncc;
   HandleScope scope(isolate);
@@ skipping 236 matching lines @@
       if (HasElementInElements(arguments, kind, index)) return true;
       break;
     }
   }
 
   // Handle [] on String objects.
   if (this->IsStringObjectWithCharacterAt(index)) return true;
 
   Object* pt = GetPrototype();
   if (pt->IsNull()) return false;
+  if (pt->IsJSProxy()) {
+    // We need to follow the spec and simulate a call to [[GetOwnProperty]].
+    return JSProxy::cast(pt)->GetElementAttributeWithHandler(
+        receiver, index) != ABSENT;
+  }
   return JSObject::cast(pt)->HasElementWithReceiver(receiver, index);
 }
 
 
 MaybeObject* JSObject::SetElementWithInterceptor(uint32_t index,
                                                  Object* value,
                                                  StrictModeFlag strict_mode,
                                                  bool check_prototype) {
   Isolate* isolate = GetIsolate();
   // Make sure that the top context does not change when doing
@@ skipping 412 matching lines @@
   ASSERT(elements()->IsFixedDoubleArray());
   Object* obj;
   { MaybeObject* maybe_obj = NormalizeElements();
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
   ASSERT(HasDictionaryElements());
   return SetElement(index, value, strict_mode, check_prototype);
 }
 
 
+MaybeObject* JSReceiver::SetElement(uint32_t index,
+                                    Object* value,
+                                    StrictModeFlag strict_mode,
+                                    bool check_proto) {
+  return IsJSProxy()
+     ? JSProxy::cast(this)->SetElementWithHandler(index, value, strict_mode)

[Rico, 2011/09/12 11:21:18]

4 space indention 

[rossberg, 2011/09/13 16:10:25]

Done.

+     : JSObject::cast(this)->SetElement(index, value, strict_mode, check_proto);
+}
+
+
 MaybeObject* JSObject::SetElement(uint32_t index,
                                   Object* value,
                                   StrictModeFlag strict_mode,
                                   bool check_prototype) {
   // Check access rights if needed.
   if (IsAccessCheckNeeded()) {
     Heap* heap = GetHeap();
     if (!heap->isolate()->MayIndexedAccess(this, index, v8::ACCESS_SET)) {
       HandleScope scope(heap->isolate());
       Handle<Object> value_handle(value);
@@ skipping 3038 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal