Relax object literal checking to follow ES6

src/ast.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 "src/ast.h"
 
 #include <cmath>  // For isfinite.
 #include "src/builtins.h"
 #include "src/code-stubs.h"
 #include "src/contexts.h"
@@ skipping 202 matching lines @@
 void ObjectLiteral::Property::set_emit_store(bool emit_store) {
   emit_store_ = emit_store;
 }
 
 
 bool ObjectLiteral::Property::emit_store() {
   return emit_store_;
 }
 
 
+enum ObjectLiteralPropertyState {
+  kNoPropertyState = 0,
+  kDataPropertyState = 1,
+  kGetterPropertyState = 2,
+  kSetterPropertyState = 3,
+  kAccessorPropertyState = 4  // Getter and setter fixed.
+};
+
+
 void ObjectLiteral::CalculateEmitStore(Zone* zone) {
   ZoneAllocationPolicy allocator(zone);
 
+  // Map of Literal -> ObjectLiteralPropertyState
   ZoneHashMap table(Literal::Match, ZoneHashMap::kDefaultHashMapCapacity,
                     allocator);
+
+  bool has_dunder_proto = false;
+
+  // Visit properties from last to first.
   for (int i = properties()->length() - 1; i >= 0; i--) {
     ObjectLiteral::Property* property = properties()->at(i);
     Literal* literal = property->key();
-    if (literal->value()->IsNull()) continue;
+    ASSERT(!literal->value()->IsNull());
     uint32_t hash = literal->Hash();
-    // If the key of a computed property is in the table, do not emit
-    // a store for the property later.
-    if ((property->kind() == ObjectLiteral::Property::MATERIALIZED_LITERAL ||
-         property->kind() == ObjectLiteral::Property::COMPUTED) &&
-        table.Lookup(literal, hash, false, allocator) != NULL) {
+
+    if (property->IsCompileTimeValue())
       property->set_emit_store(false);
-    } else {
-      // Add key to the table.
-      table.Lookup(literal, hash, true, allocator);
+
+    ObjectLiteralPropertyState old_state, new_state;
+
+    ZoneHashMap::Entry *entry = table.Lookup(literal, hash, true, allocator);
+    uintptr_t old_state_bits = reinterpret_cast<uintptr_t>(entry->value);
+    old_state = static_cast<ObjectLiteralPropertyState>(old_state_bits);
+    new_state = old_state;
+    switch (old_state) {
+      case kNoPropertyState:
+        switch (property->kind()) {
+          case ObjectLiteral::Property::CONSTANT:
+          case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+          case ObjectLiteral::Property::COMPUTED:
+            new_state = kDataPropertyState;
+            break;
+          case ObjectLiteral::Property::GETTER:
+            new_state = kGetterPropertyState;
+            break;
+          case ObjectLiteral::Property::SETTER:
+            new_state = kSetterPropertyState;
+            break;
+          case ObjectLiteral::Property::PROTOTYPE:
+            if (has_dunder_proto) property->set_emit_store(false);
+            has_dunder_proto = true;
+            continue;
+        }
+        break;
+      case kDataPropertyState:
+        // This property is overridden by a later data property.
+        switch (property->kind()) {
+          case ObjectLiteral::Property::CONSTANT:
+          case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+          case ObjectLiteral::Property::COMPUTED:
+          case ObjectLiteral::Property::GETTER:
+          case ObjectLiteral::Property::SETTER:
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::PROTOTYPE:
+            if (has_dunder_proto) property->set_emit_store(false);
+            has_dunder_proto = true;
+            break;
+        }
+        break;
+      case kGetterPropertyState:
+        switch (property->kind()) {
+          case ObjectLiteral::Property::CONSTANT:
+          case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+          case ObjectLiteral::Property::COMPUTED:
+            // This getter will not have a corresponding setter.
+            new_state = kAccessorPropertyState;
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::GETTER:
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::SETTER:
+            new_state = kAccessorPropertyState;
+            break;
+          case ObjectLiteral::Property::PROTOTYPE:
+            // This getter will not have a corresponding setter.
+            new_state = kAccessorPropertyState;
+            if (has_dunder_proto) property->set_emit_store(false);
+            has_dunder_proto = true;
+            break;
+        }
+        break;
+      case kSetterPropertyState:
+        switch (property->kind()) {
+          case ObjectLiteral::Property::CONSTANT:
+          case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+          case ObjectLiteral::Property::COMPUTED:
+            // This setter will not have a corresponding getter.
+            new_state = kAccessorPropertyState;
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::GETTER:
+            new_state = kAccessorPropertyState;
+            break;
+          case ObjectLiteral::Property::SETTER:
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::PROTOTYPE:
+            // This setter will not have a corresponding getter.
+            new_state = kAccessorPropertyState;
+            if (has_dunder_proto) property->set_emit_store(false);
+            has_dunder_proto = true;
+            break;
+        }
+        break;
+      case kAccessorPropertyState:
+        // This property is overridden by a later accessor property.
+        switch (property->kind()) {
+          case ObjectLiteral::Property::CONSTANT:
+          case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+          case ObjectLiteral::Property::COMPUTED:
+          case ObjectLiteral::Property::GETTER:
+          case ObjectLiteral::Property::SETTER:
+            property->set_emit_store(false);
+            break;
+          case ObjectLiteral::Property::PROTOTYPE:
+            if (has_dunder_proto) property->set_emit_store(false);
+            has_dunder_proto = true;
+            break;
+        }
+        break;
+      default:
+        UNREACHABLE();
     }
+    entry->value = reinterpret_cast<void*>(new_state);
   }
 }
 
 
 bool ObjectLiteral::IsBoilerplateProperty(ObjectLiteral::Property* property) {
   return property != NULL &&
          property->kind() != ObjectLiteral::Property::PROTOTYPE;
 }
 
 
@@ skipping 890 matching lines @@
     SNPrintF(buffer, "%d", Smi::cast(*value())->value());
     str = arr;
   } else {
     str = DoubleToCString(value()->Number(), buffer);
   }
   return isolate_->factory()->NewStringFromAsciiChecked(str);
 }
 
 
 } }  // namespace v8::internal