Ensure slow properties for simple {__proto__:null} literals.

src/ast/ast.h

 // 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.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 1403 matching lines @@
   ZoneList<Property*>* properties() const { return properties_; }
   bool fast_elements() const { return FastElementsField::decode(bit_field_); }
   bool may_store_doubles() const {
     return MayStoreDoublesField::decode(bit_field_);
   }
   bool has_elements() const { return HasElementsField::decode(bit_field_); }
   bool has_shallow_properties() const {
     return depth() == 1 && !has_elements() && !may_store_doubles();
   }
 
+  bool HasOnlyNullPrototype() const {
+    if (is_simple() || properties_count() != 0) return false;

[adamk, 2016/10/25 11:14:24]

I don't think properties_count() gives you the right answer...why not just check
for properties()->length() == 1?

[Camillo Bruni, 2017/03/13 17:21:44]

That's probably easier, right.

+    const ObjectLiteral::Property* property = properties()->at(0);
+    if (property->kind() != ObjectLiteral::Property::PROTOTYPE) return false;
+    return property->value()->IsNullLiteral();
+  }
+
   // Decide if a property should be in the object boilerplate.
   static bool IsBoilerplateProperty(Property* property);
 
   // Populate the constant properties fixed array.
   void BuildConstantProperties(Isolate* isolate);
 
   // Mark all computed expressions that are bound to a key that
   // is shadowed by a later occurrence of the same key. For the
   // marked expressions, no store code is emitted.
   void CalculateEmitStore(Zone* zone);
 
   // Assemble bitfield of flags for the CreateObjectLiteral helper.
   int ComputeFlags(bool disable_mementos = false) const {
-    int flags = fast_elements() ? kFastElements : kNoFlags;
+    int flags = kNoFlags;
+    // Use slow properties if we only set the null prototype.
+    if (fast_elements() && !HasOnlyNullPrototype()) {
+      flags = kFastElements;
+    }
     if (has_shallow_properties()) {
       flags |= kShallowProperties;
     }
     if (disable_mementos) {
       flags |= kDisableMementos;
     }
     return flags;
   }
 
   enum Flags {
@@ skipping 2146 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_