Add support for computed property names in object literals

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 182 matching lines @@
       ASSERT(index == number_of_string_keys);
     }
     *is_result_from_cache = true;
     return isolate->factory()->ObjectLiteralMapFromCache(context, keys);
   }
   *is_result_from_cache = false;
   return Map::Create(handle(context->object_function()), number_of_properties);
 }
 
 
+MUST_USE_RESULT static MaybeHandle<Object> DefineOrRedefineDataProperty(
+    Isolate* isolate,
+    Handle<JSObject> object,
+    Handle<Name> name,
+    Handle<Object> value,
+    PropertyAttributes attr);
+
+
 MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
     Isolate* isolate,
     Handle<FixedArray> literals,
     Handle<FixedArray> constant_properties);
 
 
 MUST_USE_RESULT static MaybeHandle<Object> CreateObjectLiteralBoilerplate(
     Isolate* isolate,
     Handle<FixedArray> literals,
     Handle<FixedArray> constant_properties,
@@ skipping 4949 matching lines @@
 
   bool fast = obj->HasFastProperties();
   // DefineAccessor checks access rights.
   JSObject::DefineAccessor(obj, name, getter, setter, attr);
   RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
   if (fast) JSObject::TransformToFastProperties(obj, 0);
   return isolate->heap()->undefined_value();
 }
 
 
-// Implements part of 8.12.9 DefineOwnProperty.
-// There are 3 cases that lead here:
-// Step 4a - define a new data property.
-// Steps 9b & 12 - replace an existing accessor property with a data property.
-// Step 12 - update an existing data property with a data or generic
-//           descriptor.
-RUNTIME_FUNCTION(Runtime_DefineOrRedefineDataProperty) {
-  HandleScope scope(isolate);
-  ASSERT(args.length() == 4);
-  CONVERT_ARG_HANDLE_CHECKED(JSObject, js_object, 0);
-  CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
-  CONVERT_ARG_HANDLE_CHECKED(Object, obj_value, 2);
-  CONVERT_SMI_ARG_CHECKED(unchecked, 3);
-  RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
-  PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
-
-  // Check access rights if needed.
-  if (js_object->IsAccessCheckNeeded() &&
-      !isolate->MayNamedAccess(js_object, name, v8::ACCESS_SET)) {
-    return isolate->heap()->undefined_value();
-  }
-
+static MaybeHandle<Object> DefineOrRedefineDataProperty(
+    Isolate* isolate,
+    Handle<JSObject> js_object,
+    Handle<Name> name,
+    Handle<Object> obj_value,
+    PropertyAttributes attr) {
   LookupResult lookup(isolate);
   js_object->LookupOwnRealNamedProperty(name, &lookup);
 
   // Take special care when attributes are different and there is already
   // a property. For simplicity we normalize the property which enables us
   // to not worry about changing the instance_descriptor and creating a new
   // map. The current version of SetObjectProperty does not handle attributes
   // correctly in the case where a property is a field and is reset with
   // new attributes.
   if (lookup.IsFound() &&
       (attr != lookup.GetAttributes() || lookup.IsPropertyCallbacks())) {
     // New attributes - normalize to avoid writing to instance descriptor
     if (js_object->IsJSGlobalProxy()) {
       // Since the result is a property, the prototype will exist so
       // we don't have to check for null.
       js_object = Handle<JSObject>(JSObject::cast(js_object->GetPrototype()));
     }
 
     if (attr != lookup.GetAttributes() ||
         (lookup.IsPropertyCallbacks() &&
          !lookup.GetCallbackObject()->IsAccessorInfo())) {
       JSObject::NormalizeProperties(js_object, CLEAR_INOBJECT_PROPERTIES, 0);
     }
 
     // Use IgnoreAttributes version since a readonly property may be
     // overridden and SetProperty does not allow this.
-    Handle<Object> result;
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, result,
-        JSObject::SetOwnPropertyIgnoreAttributes(
-            js_object, name, obj_value, attr,
-            Object::OPTIMAL_REPRESENTATION,
-            ALLOW_AS_CONSTANT,
-            JSReceiver::PERFORM_EXTENSIBILITY_CHECK,
-            JSReceiver::MAY_BE_STORE_FROM_KEYED,
-            JSObject::DONT_FORCE_FIELD));
-    return *result;
+    return JSObject::SetOwnPropertyIgnoreAttributes(
+        js_object, name, obj_value, attr,
+        Object::OPTIMAL_REPRESENTATION,
+        ALLOW_AS_CONSTANT,
+        JSReceiver::PERFORM_EXTENSIBILITY_CHECK,
+        JSReceiver::MAY_BE_STORE_FROM_KEYED,
+        JSObject::DONT_FORCE_FIELD);
+  }
+
+  return Runtime::ForceSetObjectProperty(
+      js_object, name, obj_value, attr,
+      JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED);
+}
+
+
+// Implements part of 8.12.9 DefineOwnProperty.
+// There are 3 cases that lead here:
+// Step 4a - define a new data property.
+// Steps 9b & 12 - replace an existing accessor property with a data property.
+// Step 12 - update an existing data property with a data or generic
+//           descriptor.
+RUNTIME_FUNCTION(Runtime_DefineOrRedefineDataProperty) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 4);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, js_object, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, obj_value, 2);
+  CONVERT_SMI_ARG_CHECKED(unchecked, 3);
+  RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+  PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
+
+  // Check access rights if needed.
+  if (js_object->IsAccessCheckNeeded() &&
+      !isolate->MayNamedAccess(js_object, name, v8::ACCESS_SET)) {
+    return isolate->heap()->undefined_value();
   }
 
   Handle<Object> result;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, result,
-      Runtime::ForceSetObjectProperty(
-          js_object, name, obj_value, attr,
-          JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED));
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+      DefineOrRedefineDataProperty(isolate, js_object, name, obj_value, attr));
   return *result;
 }
 
 
 // Return property without being observable by accessors or interceptors.
 RUNTIME_FUNCTION(Runtime_GetDataProperty) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
   CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
@@ skipping 225 matching lines @@
 
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       Runtime::SetObjectProperty(
           isolate, object, key, value, attributes, strict_mode));
   return *result;
 }
 
 
+// This function is only used on object literals.
+static MaybeHandle<Object> SetOwnElement(Isolate* isolate,
+                                         Handle<JSObject> object,
+                                         uint32_t index,
+                                         Handle<Object> value) {
+  StrictMode strict_mode = SLOPPY;
+
+  JSObject::ValidateElements(object);
+
+  // Object literals don't have these.
+  ASSERT(!object->HasExternalArrayElements());
+  ASSERT(!object->HasFixedTypedArrayElements());
+
+  // It is currently impossible for an object literal to have a getter or a
+  // setter for an element, though this may change when we have computed
+  // accessor property names.
+  MaybeHandle<Object> result = JSObject::SetOwnElement(
+      object, index, value, strict_mode);
+  JSObject::ValidateElements(object);
+
+  return result.is_null() ? result : value;
+}
+
+
+static MaybeHandle<Object> SetOwnProperty(Isolate* isolate,
+                                          Handle<JSObject> object,
+                                          Handle<Object> key,
+                                          Handle<Object> value) {
+  PropertyAttributes attr = NONE;
+
+  // Check if the given key is an array index.
+  uint32_t index;
+  if (key->ToArrayIndex(&index)) {
+    return SetOwnElement(isolate, object, index, value);
+  }
+
+  if (!key->IsName()) {
+    // Call back into JavaScript to convert the key to a string.
+    ASSIGN_RETURN_ON_EXCEPTION(
+        isolate, key, Execution::ToString(isolate, key), Object);
+  }
+
+  Handle<Name> name = Handle<Name>::cast(key);
+  if (name->AsArrayIndex(&index)) {
+    return SetOwnElement(isolate, object, index, value);
+  }
+
+  return DefineOrRedefineDataProperty(isolate, object, name, value, attr);
+}
+
+
+// Used to initialize data properties on object literals.  We know that the
+// attributes will be NONE.
+RUNTIME_FUNCTION(Runtime_SetOwnProperty) {
+  HandleScope scope(isolate);
+  RUNTIME_ASSERT(args.length() == 3);
+
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+
+  Handle<Object> result;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+      SetOwnProperty(isolate, object, key, value));
+  return *result;
+}
+
+
 RUNTIME_FUNCTION(Runtime_TransitionElementsKind) {
   HandleScope scope(isolate);
   RUNTIME_ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
   CONVERT_ARG_HANDLE_CHECKED(Map, map, 1);
   JSObject::TransitionElementsKind(array, map->elements_kind());
   return *array;
 }
 
 
@@ skipping 9650 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal