Reland^2 "[runtime] Slightly optimize creation of class literals."

This CL also includes fixes for CF issues found while the previous
reland was active.

Bug: v8:5799, chromium:783902, chromium:783926, chromium:783822
Change-Id: I1f7d9b037d90838469c45f5d72771a77444c662e
Reviewed-on: https://chromium-review.googlesource.com/764067Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#49457}

BUILD.gn

@@ -1796,6 +1796,7 @@ v8_source_set("v8_base") {
     "src/objects/js-array.h",
     "src/objects/js-regexp-inl.h",
     "src/objects/js-regexp.h",
+    "src/objects/literal-objects-inl.h",
     "src/objects/literal-objects.cc",
     "src/objects/literal-objects.h",
     "src/objects/map-inl.h",

src/ast/ast.cc

@@ -416,12 +416,11 @@ int ObjectLiteral::InitDepthAndFlags() {
     // much larger than the number of elements, creating an object
     // literal with fast elements will be a waste of space.
     uint32_t element_index = 0;
-    if (key->IsString() && key->AsRawString()->AsArrayIndex(&element_index)) {
-      max_element_index = Max(element_index, max_element_index);
-      elements++;
-    } else if (key->ToArrayIndex(&element_index)) {
+    if (key->AsArrayIndex(&element_index)) {
       max_element_index = Max(element_index, max_element_index);
       elements++;
+    } else {
+      DCHECK(key->IsPropertyName());
     }
 
     nof_properties++;
@@ -453,9 +452,7 @@ void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
 
     Literal* key = property->key()->AsLiteral();
 
-    uint32_t element_index = 0;
-    if (key->ToArrayIndex(&element_index) ||
-        (key->IsString() && key->AsRawString()->AsArrayIndex(&element_index))) {
+    if (!key->IsPropertyName()) {
       index_keys++;
     }
   }
@@ -484,15 +481,14 @@ void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
     // Add CONSTANT and COMPUTED properties to boilerplate. Use undefined
     // value for COMPUTED properties, the real value is filled in at
     // runtime. The enumeration order is maintained.
-    Handle<Object> key = property->key()->AsLiteral()->BuildValue(isolate);
-    Handle<Object> value = GetBoilerplateValue(property->value(), isolate);
-
+    Literal* key_literal = property->key()->AsLiteral();
     uint32_t element_index = 0;
-    if (key->IsString() && String::cast(*key)->AsArrayIndex(&element_index)) {
-      key = isolate->factory()->NewNumberFromUint(element_index);
-    } else if (key->IsNumber() && !key->ToArrayIndex(&element_index)) {
-      key = isolate->factory()->NumberToString(key);
-    }
+    Handle<Object> key =
+        key_literal->AsArrayIndex(&element_index)
+            ? isolate->factory()->NewNumberFromUint(element_index)
+            : Handle<Object>::cast(key_literal->AsRawPropertyName()->string());
+
+    Handle<Object> value = GetBoilerplateValue(property->value(), isolate);
 
     // Add name, value pair to the fixed array.
     constant_properties->set(position++, *key);
@@ -830,6 +826,8 @@ bool Literal::IsPropertyName() const {
 
 bool Literal::ToUint32(uint32_t* value) const {
   switch (type()) {
+    case kString:
+      return string_->AsArrayIndex(value);
     case kSmi:
       if (smi_ < 0) return false;
       *value = static_cast<uint32_t>(smi_);
@@ -841,7 +839,7 @@ bool Literal::ToUint32(uint32_t* value) const {
   }
 }
 
-bool Literal::ToArrayIndex(uint32_t* value) const {
+bool Literal::AsArrayIndex(uint32_t* value) const {
   return ToUint32(value) && *value != kMaxUInt32;
 }
 

src/ast/ast.h

@@ -982,6 +982,14 @@ class Literal final : public Expression {
   // Returns true if literal represents a property name (i.e. cannot be parsed
   // as array indices).
   bool IsPropertyName() const;
+
+  // Returns true if literal represents an array index.
+  // Note, that in general the following statement is not true:
+  //   key->IsPropertyName() != key->AsArrayIndex(...)
+  // but for non-computed LiteralProperty properties the following is true:
+  //   property->key()->IsPropertyName() != property->key()->AsArrayIndex(...)
+  bool AsArrayIndex(uint32_t* index) const;
+
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
     return string_;
@@ -1026,7 +1034,6 @@ class Literal final : public Expression {
   bool ToBooleanIsFalse() const { return !ToBooleanIsTrue(); }
 
   bool ToUint32(uint32_t* value) const;
-  bool ToArrayIndex(uint32_t* value) const;
 
   // Returns an appropriate Object representing this Literal, allocating
   // a heap object if needed.

src/compiler/code-assembler.h

@@ -191,6 +191,7 @@ enum class ObjectType {
 #undef ENUM_STRUCT_ELEMENT
 
 class AccessCheckNeeded;
+class ClassBoilerplate;
 class CompilationCacheTable;
 class Constructor;
 class Filler;

src/factory.cc

@@ -3080,6 +3080,15 @@ Handle<Map> Factory::CreateStrictFunctionMap(
     map->AppendDescriptor(&d);
   }
 
+  STATIC_ASSERT(JSFunction::kMaybeHomeObjectDescriptorIndex == 2);
+  if (IsFunctionModeWithHomeObject(function_mode)) {
+    // Add home object field.
+    Handle<Name> name = isolate()->factory()->home_object_symbol();
+    Descriptor d = Descriptor::DataField(name, field_index++, DONT_ENUM,
+                                         Representation::Tagged());
+    map->AppendDescriptor(&d);
+  }
+
   if (IsFunctionModeWithPrototype(function_mode)) {
     // Add prototype accessor.
     PropertyAttributes attribs =
@@ -3089,14 +3098,6 @@ Handle<Map> Factory::CreateStrictFunctionMap(
         prototype_string(), function_prototype_accessor(), attribs);
     map->AppendDescriptor(&d);
   }
-
-  if (IsFunctionModeWithHomeObject(function_mode)) {
-    // Add home object field.
-    Handle<Name> name = isolate()->factory()->home_object_symbol();
-    Descriptor d = Descriptor::DataField(name, field_index++, DONT_ENUM,
-                                         Representation::Tagged());
-    map->AppendDescriptor(&d);
-  }
   DCHECK_EQ(inobject_properties_count, field_index);
   return map;
 }
@@ -3105,6 +3106,7 @@ Handle<Map> Factory::CreateClassFunctionMap(Handle<JSFunction> empty_function) {
   Handle<Map> map = NewMap(JS_FUNCTION_TYPE, JSFunction::kSizeWithPrototype);
   map->set_has_prototype_slot(true);
   map->set_is_constructor(true);
+  map->set_is_prototype_map(true);
   map->set_is_callable();
   Map::SetPrototype(map, empty_function);
 
@@ -3113,8 +3115,8 @@ Handle<Map> Factory::CreateClassFunctionMap(Handle<JSFunction> empty_function) {
   //
   Map::EnsureDescriptorSlack(map, 2);
 
-  PropertyAttributes rw_attribs =
-      static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
+  PropertyAttributes ro_attribs =
+      static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
   PropertyAttributes roc_attribs =
       static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY);
 
@@ -3128,7 +3130,7 @@ Handle<Map> Factory::CreateClassFunctionMap(Handle<JSFunction> empty_function) {
   {
     // Add prototype accessor.
     Descriptor d = Descriptor::AccessorConstant(
-        prototype_string(), function_prototype_accessor(), rw_attribs);
+        prototype_string(), function_prototype_accessor(), ro_attribs);
     map->AppendDescriptor(&d);
   }
   return map;

src/heap/heap.h

@@ -288,6 +288,7 @@ using v8::MemoryPressureLevel;
   V(CatchContextMap)                    \
   V(CellMap)                            \
   V(CodeMap)                            \
+  V(DescriptorArrayMap)                 \
   V(EmptyByteArray)                     \
   V(EmptyDescriptorArray)               \
   V(EmptyFixedArray)                    \

src/interpreter/bytecode-generator.h

@@ -154,9 +154,6 @@ class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
   void VisitArgumentsObject(Variable* variable);
   void VisitRestArgumentsArray(Variable* rest);
   void VisitCallSuper(Call* call);
-  void VisitClassLiteralProperties(ClassLiteral* expr, Register constructor,
-                                   Register prototype);
-  void BuildClassLiteralNameProperty(ClassLiteral* expr, Register constructor);
   void BuildClassLiteral(ClassLiteral* expr);
   void VisitNewTargetVariable(Variable* variable);
   void VisitThisFunctionVariable(Variable* variable);
@@ -309,6 +306,7 @@ class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
       native_function_literals_;
   ZoneVector<std::pair<ObjectLiteral*, size_t>> object_literals_;
   ZoneVector<std::pair<ArrayLiteral*, size_t>> array_literals_;
+  ZoneVector<std::pair<ClassLiteral*, size_t>> class_literals_;
   ZoneVector<std::pair<GetTemplateObject*, size_t>> template_objects_;
 
   ControlScope* execution_control_;

src/objects-inl.h

@@ -152,6 +152,8 @@ bool HeapObject::IsJSGeneratorObject() const {
 
 bool HeapObject::IsBoilerplateDescription() const { return IsFixedArray(); }
 
+bool HeapObject::IsClassBoilerplate() const { return IsFixedArray(); }
+
 bool HeapObject::IsExternal() const {
   return map()->FindRootMap() == GetHeap()->external_map();
 }

src/objects-printer.cc

@@ -1150,6 +1150,9 @@ void SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) {  // NOLINT
     os << "<no-shared-name>";
   }
   os << "\n - kind = " << kind();
+  if (needs_home_object()) {
+    os << "\n - needs_home_object";
+  }
   os << "\n - function_map_index = " << function_map_index();
   os << "\n - formal_parameter_count = " << internal_formal_parameter_count();
   os << "\n - expected_nof_properties = " << expected_nof_properties();

src/objects.cc

@@ -15633,6 +15633,7 @@ template <typename Derived, typename Shape>
 void Dictionary<Derived, Shape>::Print() {
   OFStream os(stdout);
   Print(os);
+  os << std::endl;
 }
 #endif
 
@@ -17426,6 +17427,23 @@ Handle<Derived> Dictionary<Derived, Shape>::AtPut(Handle<Derived> dictionary,
   return dictionary;
 }
 
+template <typename Derived, typename Shape>
+Handle<Derived>
+BaseNameDictionary<Derived, Shape>::AddNoUpdateNextEnumerationIndex(
+    Handle<Derived> dictionary, Key key, Handle<Object> value,
+    PropertyDetails details, int* entry_out) {
+  // Insert element at empty or deleted entry
+  return Dictionary<Derived, Shape>::Add(dictionary, key, value, details,
+                                         entry_out);
+}
+
+// GCC workaround: Explicitly instantiate template method for NameDictionary
+// to avoid "undefined reference" issues during linking.
+template Handle<NameDictionary>
+BaseNameDictionary<NameDictionary, NameDictionaryShape>::
+    AddNoUpdateNextEnumerationIndex(Handle<NameDictionary>, Handle<Name>,
+                                    Handle<Object>, PropertyDetails, int*);
+
 template <typename Derived, typename Shape>
 Handle<Derived> BaseNameDictionary<Derived, Shape>::Add(
     Handle<Derived> dictionary, Key key, Handle<Object> value,
@@ -17437,7 +17455,7 @@ Handle<Derived> BaseNameDictionary<Derived, Shape>::Add(
   int index = dictionary->NextEnumerationIndex();
   details = details.set_index(index);
   dictionary->SetNextEnumerationIndex(index + 1);
-  return Dictionary<Derived, Shape>::Add(dictionary, key, value, details,
+  return AddNoUpdateNextEnumerationIndex(dictionary, key, value, details,
                                          entry_out);
 }
 

src/objects.h

@@ -977,6 +977,7 @@ template <class C> inline bool Is(Object* obj);
   V(Callable)                             \
   V(CallHandlerInfo)                      \
   V(Cell)                                 \
+  V(ClassBoilerplate)                     \
   V(Code)                                 \
   V(CodeDataContainer)                    \
   V(CompilationCacheTable)                \
@@ -3933,6 +3934,8 @@ class JSFunction: public JSObject {
 
   static const int kLengthDescriptorIndex = 0;
   static const int kNameDescriptorIndex = 1;
+  // Home object descriptor index when function has a [[HomeObject]] slot.
+  static const int kMaybeHomeObjectDescriptorIndex = 2;
 
   // [context]: The context for this function.
   inline Context* context();

src/objects/dictionary.h

@@ -172,6 +172,10 @@ class BaseNameDictionary : public Dictionary<Derived, Shape> {
   // Ensure enough space for n additional elements.
   static Handle<Derived> EnsureCapacity(Handle<Derived> dictionary, int n);
 
+  MUST_USE_RESULT static Handle<Derived> AddNoUpdateNextEnumerationIndex(
+      Handle<Derived> dictionary, Key key, Handle<Object> value,
+      PropertyDetails details, int* entry_out = nullptr);
+
   MUST_USE_RESULT static Handle<Derived> Add(Handle<Derived> dictionary,
                                              Key key, Handle<Object> value,
                                              PropertyDetails details,

src/objects/literal-objects-inl.h

+// Copyright 2017 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_LITERAL_OBJECTS_INL_H_
+#define V8_LITERAL_OBJECTS_INL_H_
+
+#include "src/objects-inl.h"
+#include "src/objects/literal-objects.h"
+
+// Has to be the last include (doesn't have include guards):
+#include "src/objects/object-macros.h"
+
+namespace v8 {
+namespace internal {
+
+CAST_ACCESSOR(ClassBoilerplate)
+
+BIT_FIELD_ACCESSORS(ClassBoilerplate, flags, install_class_name_accessor,
+                    ClassBoilerplate::Flags::InstallClassNameAccessorBit)
+
+BIT_FIELD_ACCESSORS(ClassBoilerplate, flags, arguments_count,
+                    ClassBoilerplate::Flags::ArgumentsCountBits)
+
+SMI_ACCESSORS(ClassBoilerplate, flags,
+              FixedArray::OffsetOfElementAt(kFlagsIndex));
+
+ACCESSORS(ClassBoilerplate, static_properties_template, Object,
+          FixedArray::OffsetOfElementAt(kClassPropertiesTemplateIndex));
+
+ACCESSORS(ClassBoilerplate, static_elements_template, Object,
+          FixedArray::OffsetOfElementAt(kClassElementsTemplateIndex));
+
+ACCESSORS(ClassBoilerplate, static_computed_properties, FixedArray,
+          FixedArray::OffsetOfElementAt(kClassComputedPropertiesIndex));
+
+ACCESSORS(ClassBoilerplate, instance_properties_template, Object,
+          FixedArray::OffsetOfElementAt(kPrototypePropertiesTemplateIndex));
+
+ACCESSORS(ClassBoilerplate, instance_elements_template, Object,
+          FixedArray::OffsetOfElementAt(kPrototypeElementsTemplateIndex));
+
+ACCESSORS(ClassBoilerplate, instance_computed_properties, FixedArray,
+          FixedArray::OffsetOfElementAt(kPrototypeComputedPropertiesIndex));
+
+}  // namespace internal
+}  // namespace v8
+
+#include "src/objects/object-macros-undef.h"
+
+#endif  // V8_LITERAL_OBJECTS_INL_H_

src/objects/literal-objects.h

@@ -13,6 +13,8 @@
 namespace v8 {
 namespace internal {
 
+class ClassLiteral;
+
 // BoilerplateDescription is a list of properties consisting of name value
 // pairs. In addition to the properties, it provides the projected number
 // of properties in the backing store. This number includes properties with
@@ -56,6 +58,79 @@ class ConstantElementsPair : public Tuple2 {
   DISALLOW_IMPLICIT_CONSTRUCTORS(ConstantElementsPair);
 };
 
+class ClassBoilerplate : public FixedArray {
+ public:
+  enum ValueKind { kData, kGetter, kSetter };
+
+  struct Flags {
+#define FLAGS_BIT_FIELDS(V, _)               \
+  V(InstallClassNameAccessorBit, bool, 1, _) \
+  V(ArgumentsCountBits, int, 30, _)
+    DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS)
+#undef FLAGS_BIT_FIELDS
+  };
+
+  struct ComputedEntryFlags {
+#define COMPUTED_ENTRY_BIT_FIELDS(V, _) \
+  V(ValueKindBits, ValueKind, 2, _)     \
+  V(KeyIndexBits, unsigned, 29, _)
+    DEFINE_BIT_FIELDS(COMPUTED_ENTRY_BIT_FIELDS)
+#undef COMPUTED_ENTRY_BIT_FIELDS
+  };
+
+  enum DefineClassArgumentsIndices {
+    kConstructorArgumentIndex = 1,
+    kPrototypeArgumentIndex = 2,
+    // The index of a first dynamic argument passed to Runtime::kDefineClass
+    // function. The dynamic arguments are consist of method closures and
+    // computed property names.
+    kFirstDynamicArgumentIndex = 3,
+  };
+
+  static const int kMinimumClassPropertiesCount = 6;
+  static const int kMinimumPrototypePropertiesCount = 1;
+
+  DECL_CAST(ClassBoilerplate)
+
+  DECL_BOOLEAN_ACCESSORS(install_class_name_accessor)
+  DECL_INT_ACCESSORS(arguments_count)
+  DECL_ACCESSORS(static_properties_template, Object)
+  DECL_ACCESSORS(static_elements_template, Object)
+  DECL_ACCESSORS(static_computed_properties, FixedArray)
+  DECL_ACCESSORS(instance_properties_template, Object)
+  DECL_ACCESSORS(instance_elements_template, Object)
+  DECL_ACCESSORS(instance_computed_properties, FixedArray)
+
+  static void AddToPropertiesTemplate(Isolate* isolate,
+                                      Handle<NameDictionary> dictionary,
+                                      Handle<Name> name, int key_index,
+                                      ValueKind value_kind, Object* value);
+
+  static void AddToElementsTemplate(Isolate* isolate,
+                                    Handle<NumberDictionary> dictionary,
+                                    uint32_t key, int key_index,
+                                    ValueKind value_kind, Object* value);
+
+  static Handle<ClassBoilerplate> BuildClassBoilerplate(Isolate* isolate,
+                                                        ClassLiteral* expr);
+
+  enum {
+    kFlagsIndex,
+    kClassPropertiesTemplateIndex,
+    kClassElementsTemplateIndex,
+    kClassComputedPropertiesIndex,
+    kPrototypePropertiesTemplateIndex,
+    kPrototypeElementsTemplateIndex,
+    kPrototypeComputedPropertiesIndex,
+    kBoileplateLength  // last element
+  };
+
+  static const int kFullComputedEntrySize = 2;
+
+ private:
+  DECL_INT_ACCESSORS(flags)
+};
+
 }  // namespace internal
 }  // namespace v8
 

src/objects/shared-function-info.h

@@ -502,16 +502,18 @@ class SharedFunctionInfo : public HeapObject {
   DEFINE_BIT_FIELDS(DEBUGGER_HINTS_BIT_FIELDS)
 #undef DEBUGGER_HINTS_BIT_FIELDS
 
+  // Indicates that this function uses a super property (or an eval that may
+  // use a super property).
+  // This is needed to set up the [[HomeObject]] on the function instance.
+  inline bool needs_home_object() const;
+
  private:
   // [raw_name]: Function name string or kNoSharedNameSentinel.
   DECL_ACCESSORS(raw_name, Object)
 
   inline void set_kind(FunctionKind kind);
 
-  // Indicates that this function uses a super property (or an eval that may
-  // use a super property).
-  // This is needed to set up the [[HomeObject]] on the function instance.
-  DECL_BOOLEAN_ACCESSORS(needs_home_object)
+  inline void set_needs_home_object(bool value);
 
   friend class Factory;
   friend class V8HeapExplorer;

src/runtime/runtime.h

@@ -80,23 +80,21 @@ namespace internal {
   F(BigIntToNumber, 1, 1)            \
   F(BigIntUnaryOp, 2, 1)
 
-#define FOR_EACH_INTRINSIC_CLASSES(F)        \
-  F(ThrowUnsupportedSuperError, 0, 1)        \
-  F(ThrowConstructorNonCallableError, 1, 1)  \
-  F(ThrowStaticPrototypeError, 0, 1)         \
-  F(ThrowSuperAlreadyCalledError, 0, 1)      \
-  F(ThrowSuperNotCalled, 0, 1)               \
-  F(ThrowNotSuperConstructor, 2, 1)          \
-  F(HomeObjectSymbol, 0, 1)                  \
-  F(DefineClass, 4, 1)                       \
-  F(InstallClassNameAccessor, 1, 1)          \
-  F(InstallClassNameAccessorWithCheck, 1, 1) \
-  F(LoadFromSuper, 3, 1)                     \
-  F(LoadKeyedFromSuper, 3, 1)                \
-  F(StoreToSuper_Strict, 4, 1)               \
-  F(StoreToSuper_Sloppy, 4, 1)               \
-  F(StoreKeyedToSuper_Strict, 4, 1)          \
-  F(StoreKeyedToSuper_Sloppy, 4, 1)          \
+#define FOR_EACH_INTRINSIC_CLASSES(F)       \
+  F(ThrowUnsupportedSuperError, 0, 1)       \
+  F(ThrowConstructorNonCallableError, 1, 1) \
+  F(ThrowStaticPrototypeError, 0, 1)        \
+  F(ThrowSuperAlreadyCalledError, 0, 1)     \
+  F(ThrowSuperNotCalled, 0, 1)              \
+  F(ThrowNotSuperConstructor, 2, 1)         \
+  F(HomeObjectSymbol, 0, 1)                 \
+  F(DefineClass, -1 /* >= 3 */, 1)          \
+  F(LoadFromSuper, 3, 1)                    \
+  F(LoadKeyedFromSuper, 3, 1)               \
+  F(StoreToSuper_Strict, 4, 1)              \
+  F(StoreToSuper_Sloppy, 4, 1)              \
+  F(StoreKeyedToSuper_Strict, 4, 1)         \
+  F(StoreKeyedToSuper_Sloppy, 4, 1)         \
   F(GetSuperConstructor, 1, 1)
 
 #define FOR_EACH_INTRINSIC_COLLECTIONS(F) \

src/v8.gyp

@@ -1172,6 +1172,7 @@
         'objects/js-regexp.h',
         'objects/js-regexp-inl.h',
         'objects/literal-objects.cc',
+        'objects/literal-objects-inl.h',
         'objects/literal-objects.h',
         'objects/map-inl.h',
         'objects/map.h',

test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden

@@ -12,40 +12,28 @@ snippet: "
     speak() { console.log(this.name + ' is speaking.'); }
   }
 "
-frame size: 8
+frame size: 6
 parameter count: 1
-bytecode array length: 67
+bytecode array length: 31
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
                 B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(LdaSmi), I8(34),
-                B(Star), R(5),
-                B(Wide), B(LdaSmi), I16(148),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
-                B(Star), R(3),
-                B(LdaConstant), U8(1),
-                B(Star), R(5),
+                B(LdaConstant), U8(0),
+                B(Star), R(2),
                 B(CreateClosure), U8(2), U8(1), U8(2),
-                B(Star), R(6),
-                B(LdaSmi), I8(2),
-                B(Star), R(7),
-                B(Ldar), R(6),
-                B(StaDataPropertyInLiteral), R(3), R(5), U8(1), U8(2),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(2), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(Star), R(5),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
                 B(Star), R(0),
                 B(Star), R(1),
                 B(LdaUndefined),
   /*  149 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
-  ONE_BYTE_INTERNALIZED_STRING_TYPE ["speak"],
   SHARED_FUNCTION_INFO_TYPE,
 ]
 handlers: [
@@ -58,40 +46,28 @@ snippet: "
     speak() { console.log(this.name + ' is speaking.'); }
   }
 "
-frame size: 8
+frame size: 6
 parameter count: 1
-bytecode array length: 67
+bytecode array length: 31
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
                 B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(LdaSmi), I8(34),
-                B(Star), R(5),
-                B(Wide), B(LdaSmi), I16(148),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
-                B(Star), R(3),
-                B(LdaConstant), U8(1),
-                B(Star), R(5),
+                B(LdaConstant), U8(0),
+                B(Star), R(2),
                 B(CreateClosure), U8(2), U8(1), U8(2),
-                B(Star), R(6),
-                B(LdaSmi), I8(2),
-                B(Star), R(7),
-                B(Ldar), R(6),
-                B(StaDataPropertyInLiteral), R(3), R(5), U8(1), U8(2),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(2), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(Star), R(5),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
                 B(Star), R(0),
                 B(Star), R(1),
                 B(LdaUndefined),
   /*  149 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
-  ONE_BYTE_INTERNALIZED_STRING_TYPE ["speak"],
   SHARED_FUNCTION_INFO_TYPE,
 ]
 handlers: [
@@ -106,9 +82,9 @@ snippet: "
     static [n1]() { return n1; }
   }
 "
-frame size: 9
+frame size: 10
 parameter count: 1
-bytecode array length: 106
+bytecode array length: 68
 bytecodes: [
                 B(CreateFunctionContext), U8(2),
                 B(PushContext), R(2),
@@ -117,36 +93,25 @@ bytecodes: [
   /*   43 E> */ B(StaCurrentContextSlot), U8(4),
   /*   57 S> */ B(LdaConstant), U8(1),
   /*   57 E> */ B(StaCurrentContextSlot), U8(5),
-                B(CreateClosure), U8(2), U8(0), U8(2),
-                B(Star), R(3),
                 B(LdaTheHole),
+                B(Star), R(5),
+                B(CreateClosure), U8(3), U8(0), U8(2),
                 B(Star), R(4),
-                B(LdaSmi), I8(62),
-                B(Star), R(6),
-                B(Wide), B(LdaSmi), I16(128),
-                B(Star), R(7),
-                B(Mov), R(3), R(5),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(4), U8(4),
-                B(Star), R(4),
+                B(LdaConstant), U8(2),
+                B(Star), R(3),
                 B(LdaImmutableCurrentContextSlot), U8(4),
   /*   75 E> */ B(ToName), R(6),
-                B(CreateClosure), U8(3), U8(1), U8(2),
+                B(CreateClosure), U8(4), U8(1), U8(2),
                 B(Star), R(7),
-                B(LdaSmi), I8(2),
-                B(Star), R(8),
-                B(Ldar), R(7),
-                B(StaDataPropertyInLiteral), R(4), R(6), U8(3), U8(2),
                 B(LdaImmutableCurrentContextSlot), U8(5),
-  /*  106 E> */ B(ToName), R(6),
-                B(LdaConstant), U8(4),
-                B(TestEqualStrictNoFeedback), R(6),
-                B(Mov), R(3), R(5),
+  /*  106 E> */ B(ToName), R(8),
+                B(LdaConstant), U8(5),
+                B(TestEqualStrictNoFeedback), R(8),
                 B(JumpIfFalse), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowStaticPrototypeError), R(0), U8(0),
-                B(CreateClosure), U8(5), U8(4), U8(2),
-                B(StaDataPropertyInLiteral), R(5), R(6), U8(3), U8(5),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessorWithCheck), R(3), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
+                B(CreateClosure), U8(6), U8(2), U8(2),
+                B(Star), R(9),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(7),
                 B(Star), R(0),
                 B(Star), R(1),
                 B(LdaUndefined),
@@ -155,6 +120,7 @@ bytecodes: [
 constant pool: [
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["a"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["b"],
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["prototype"],
@@ -169,34 +135,29 @@ snippet: "
   class C { constructor() { count++; }}
   return new C();
 "
-frame size: 8
+frame size: 6
 parameter count: 1
-bytecode array length: 55
+bytecode array length: 36
 bytecodes: [
                 B(CreateFunctionContext), U8(1),
                 B(PushContext), R(2),
   /*   30 E> */ B(StackCheck),
   /*   46 S> */ B(LdaZero),
   /*   46 E> */ B(StaCurrentContextSlot), U8(4),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(3),
                 B(LdaTheHole),
+                B(Star), R(5),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(4),
-                B(LdaSmi), I8(49),
-                B(Star), R(6),
-                B(LdaSmi), I8(86),
-                B(Star), R(7),
-                B(Mov), R(3), R(5),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(4), U8(4),
-                B(Star), R(4),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(3), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
+                B(LdaConstant), U8(0),
+                B(Star), R(3),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(3),
                 B(Star), R(0),
                 B(Star), R(1),
   /*   94 S> */ B(Construct), R(1), R(0), U8(0), U8(1),
   /*  102 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
 ]
 handlers: [
@@ -207,52 +168,37 @@ snippet: "
   (class {})
   class E { static name () {}}
 "
-frame size: 8
+frame size: 6
 parameter count: 1
-bytecode array length: 92
+bytecode array length: 49
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-  /*   34 S> */ B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
-                B(LdaTheHole),
-                B(Star), R(3),
-                B(LdaSmi), I8(35),
-                B(Star), R(5),
-                B(LdaSmi), I8(43),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
+  /*   34 S> */ B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
-                B(CreateClosure), U8(1), U8(1), U8(2),
+                B(LdaConstant), U8(0),
                 B(Star), R(2),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(3),
                 B(LdaTheHole),
-                B(Star), R(3),
-                B(LdaSmi), I8(45),
-                B(Star), R(5),
-                B(LdaSmi), I8(73),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
+                B(Star), R(4),
+                B(CreateClosure), U8(3), U8(1), U8(2),
                 B(Star), R(3),
                 B(LdaConstant), U8(2),
+                B(Star), R(2),
+                B(CreateClosure), U8(4), U8(2), U8(2),
                 B(Star), R(5),
-                B(CreateClosure), U8(3), U8(2), U8(2),
-                B(Star), R(6),
-                B(LdaSmi), I8(2),
-                B(Star), R(7),
-                B(Ldar), R(6),
-                B(StaDataPropertyInLiteral), R(4), R(5), U8(1), U8(3),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
                 B(Star), R(0),
                 B(Star), R(1),
                 B(LdaUndefined),
   /*   74 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
-  ONE_BYTE_INTERNALIZED_STRING_TYPE ["name"],
   SHARED_FUNCTION_INFO_TYPE,
 ]
 handlers: [

test/cctest/interpreter/bytecode_expectations/Modules.golden

@@ -505,9 +505,9 @@ handlers: [
 snippet: "
   export default (class {});
 "
-frame size: 8
+frame size: 6
 parameter count: 2
-bytecode array length: 140
+bytecode array length: 121
 bytecodes: [
                 B(Ldar), R(1),
                 B(JumpIfUndefined), U8(18),
@@ -548,19 +548,13 @@ bytecodes: [
   /*   26 S> */ B(Return),
                 B(Ldar), R(3),
                 B(StaCurrentContextSlot), U8(5),
-                B(CreateClosure), U8(4), U8(0), U8(0),
-                B(Star), R(3),
                 B(LdaTheHole),
+                B(Star), R(5),
+                B(CreateClosure), U8(5), U8(0), U8(0),
                 B(Star), R(4),
-                B(LdaSmi), I8(16),
-                B(Star), R(6),
-                B(LdaSmi), I8(24),
-                B(Star), R(7),
-                B(Mov), R(3), R(5),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(4), U8(4),
-                B(Star), R(4),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(3), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
+                B(LdaConstant), U8(4),
+                B(Star), R(3),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(3),
                 B(StaModuleVariable), I8(1), U8(0),
                 B(LdaCurrentContextSlot), U8(5),
   /*   26 S> */ B(Return),
@@ -570,6 +564,7 @@ constant pool: [
   FIXED_ARRAY_TYPE,
   Smi [10],
   Smi [7],
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
 ]
 handlers: [

test/cctest/interpreter/bytecode_expectations/NewAndSpread.golden

@@ -10,27 +10,21 @@ snippet: "
   class A { constructor(...args) { this.args = args; } }
   new A(...[1, 2, 3]);
 "
-frame size: 7
+frame size: 5
 parameter count: 1
-bytecode array length: 57
+bytecode array length: 38
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
                 B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(LdaSmi), I8(34),
-                B(Star), R(5),
-                B(LdaSmi), I8(88),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
-                B(Star), R(3),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(2), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(LdaConstant), U8(0),
+                B(Star), R(2),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(3),
                 B(Star), R(0),
                 B(Star), R(1),
-  /*   89 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(37),
+  /*   89 S> */ B(CreateArrayLiteral), U8(2), U8(1), U8(37),
                 B(Star), R(3),
                 B(Ldar), R(1),
   /*   89 E> */ B(ConstructWithSpread), R(1), R(3), U8(1), U8(2),
@@ -38,6 +32,7 @@ bytecodes: [
   /*  110 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
   TUPLE2_TYPE,
 ]
@@ -49,29 +44,23 @@ snippet: "
   class A { constructor(...args) { this.args = args; } }
   new A(0, ...[1, 2, 3]);
 "
-frame size: 7
+frame size: 5
 parameter count: 1
-bytecode array length: 60
+bytecode array length: 41
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
                 B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(LdaSmi), I8(34),
-                B(Star), R(5),
-                B(LdaSmi), I8(88),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
-                B(Star), R(3),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(2), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(LdaConstant), U8(0),
+                B(Star), R(2),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(3),
                 B(Star), R(0),
                 B(Star), R(1),
   /*   89 S> */ B(LdaZero),
                 B(Star), R(3),
-                B(CreateArrayLiteral), U8(1), U8(1), U8(37),
+                B(CreateArrayLiteral), U8(2), U8(1), U8(37),
                 B(Star), R(4),
                 B(Ldar), R(1),
   /*   89 E> */ B(ConstructWithSpread), R(1), R(3), U8(2), U8(2),
@@ -79,6 +68,7 @@ bytecodes: [
   /*  113 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
   TUPLE2_TYPE,
 ]
@@ -90,33 +80,27 @@ snippet: "
   class A { constructor(...args) { this.args = args; } }
   new A(0, ...[1, 2, 3], 4);
 "
-frame size: 7
+frame size: 6
 parameter count: 1
-bytecode array length: 81
+bytecode array length: 62
 bytecodes: [
   /*   30 E> */ B(StackCheck),
-                B(CreateClosure), U8(0), U8(0), U8(2),
-                B(Star), R(2),
                 B(LdaTheHole),
+                B(Star), R(4),
+                B(CreateClosure), U8(1), U8(0), U8(2),
                 B(Star), R(3),
-                B(LdaSmi), I8(34),
-                B(Star), R(5),
-                B(LdaSmi), I8(88),
-                B(Star), R(6),
-                B(Mov), R(2), R(4),
-                B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
-                B(Star), R(3),
-                B(CallRuntime), U16(Runtime::kInstallClassNameAccessor), R(2), U8(1),
-                B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+                B(LdaConstant), U8(0),
+                B(Star), R(2),
+                B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(3),
                 B(Star), R(0),
                 B(Star), R(1),
-  /*   89 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(37),
+  /*   89 S> */ B(CreateArrayLiteral), U8(2), U8(1), U8(37),
                 B(Star), R(3),
-                B(CreateArrayLiteral), U8(2), U8(2), U8(37),
+                B(CreateArrayLiteral), U8(3), U8(2), U8(37),
                 B(Star), R(4),
                 B(CallJSRuntime), U8(%spread_iterable), R(4), U8(1),
                 B(Star), R(4),
-                B(CreateArrayLiteral), U8(3), U8(3), U8(37),
+                B(CreateArrayLiteral), U8(4), U8(3), U8(37),
                 B(Star), R(5),
                 B(CallJSRuntime), U8(%spread_arguments), R(3), U8(3),
                 B(Star), R(3),
@@ -126,6 +110,7 @@ bytecodes: [
   /*  116 S> */ B(Return),
 ]
 constant pool: [
+  FIXED_ARRAY_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
   TUPLE2_TYPE,
   TUPLE2_TYPE,

test/mjsunit/es6/class-computed-property-names-super.js

@@ -9,6 +9,52 @@ function ID(x) {
   return x;
 }
 
+function assertMethodDescriptor(object, name) {
+  var descr = Object.getOwnPropertyDescriptor(object, name);
+  assertTrue(descr.configurable);
+  assertFalse(descr.enumerable);
+  assertTrue(descr.writable);
+  assertEquals('function', typeof descr.value);
+  assertFalse('prototype' in descr.value);
+  assertEquals("" + name, descr.value.name);
+}
+
+
+function assertGetterDescriptor(object, name) {
+  var descr = Object.getOwnPropertyDescriptor(object, name);
+  assertTrue(descr.configurable);
+  assertFalse(descr.enumerable);
+  assertEquals('function', typeof descr.get);
+  assertFalse('prototype' in descr.get);
+  assertEquals(undefined, descr.set);
+  assertEquals("get " + name, descr.get.name);
+}
+
+
+function assertSetterDescriptor(object, name) {
+  var descr = Object.getOwnPropertyDescriptor(object, name);
+  assertTrue(descr.configurable);
+  assertFalse(descr.enumerable);
+  assertEquals(undefined, descr.get);
+  assertEquals('function', typeof descr.set);
+  assertFalse('prototype' in descr.set);
+  assertEquals("set " + name, descr.set.name);
+}
+
+
+function assertAccessorDescriptor(object, name) {
+  var descr = Object.getOwnPropertyDescriptor(object, name);
+  assertTrue(descr.configurable);
+  assertFalse(descr.enumerable);
+  assertEquals('function', typeof descr.get);
+  assertEquals('function', typeof descr.set);
+  assertFalse('prototype' in descr.get);
+  assertFalse('prototype' in descr.set);
+  assertEquals("get " + name, descr.get.name);
+  assertEquals("set " + name, descr.set.name);
+}
+
+
 
 (function TestComputedMethodSuper() {
   class Base {
@@ -21,14 +67,28 @@ function ID(x) {
     [ID('b')]() { return 'b' + super.m(); }
     [0]() { return '0' + super.m(); }
     [ID(1)]() { return '1' + super.m(); }
+    [ID(2147483649)]() { return '2147483649' + super.m(); }
+    [ID(4294967294)]() { return '4294967294' + super.m(); }
+    [ID(4294967295)]() { return '4294967295' + super.m(); }
   }
 
   assertSame(Derived.prototype, Derived.prototype.a[%HomeObjectSymbol()]);
 
+  assertMethodDescriptor(Derived.prototype, "a");
+  assertMethodDescriptor(Derived.prototype, "b");
+  assertMethodDescriptor(Derived.prototype, 0);
+  assertMethodDescriptor(Derived.prototype, 1);
+  assertMethodDescriptor(Derived.prototype, 2147483649);
+  assertMethodDescriptor(Derived.prototype, 4294967294);
+  assertMethodDescriptor(Derived.prototype, 4294967295);
+
   assertEquals('a base m', new Derived().a());
   assertEquals('b base m', new Derived().b());
   assertEquals('0 base m', new Derived()[0]());
   assertEquals('1 base m', new Derived()[1]());
+  assertEquals('2147483649 base m', new Derived()[2147483649]());
+  assertEquals('4294967294 base m', new Derived()[4294967294]());
+  assertEquals('4294967295 base m', new Derived()[4294967295]());
 })();
 
 
@@ -43,11 +103,26 @@ function ID(x) {
     get [ID('b')]() { return 'b' + super.m(); }
     get [0]() { return '0' + super.m(); }
     get [ID(1)]() { return '1' + super.m(); }
+    get [ID(2147483649)]() { return '2147483649' + super.m(); }
+    get [ID(4294967294)]() { return '4294967294' + super.m(); }
+    get [ID(4294967295)]() { return '4294967295' + super.m(); }
   }
+
+  assertGetterDescriptor(Derived.prototype, "a");
+  assertGetterDescriptor(Derived.prototype, "b");
+  assertGetterDescriptor(Derived.prototype, 0);
+  assertGetterDescriptor(Derived.prototype, 1);
+  assertGetterDescriptor(Derived.prototype, 2147483649);
+  assertGetterDescriptor(Derived.prototype, 4294967294);
+  assertGetterDescriptor(Derived.prototype, 4294967295);
+
   assertEquals('a base m', new Derived().a);
   assertEquals('b base m', new Derived().b);
   assertEquals('0 base m', new Derived()[0]);
   assertEquals('1 base m', new Derived()[1]);
+  assertEquals('2147483649 base m', new Derived()[2147483649]);
+  assertEquals('4294967294 base m', new Derived()[4294967294]);
+  assertEquals('4294967295 base m', new Derived()[4294967295]);
 })();
 
 
@@ -63,7 +138,18 @@ function ID(x) {
     set [ID('b')](v) { super.m('b', v); }
     set [0](v) { super.m('0', v); }
     set [ID(1)](v) { super.m('1', v); }
+    set [ID(2147483649)](v) { super.m('2147483649', v); }
+    set [ID(4294967294)](v) { super.m('4294967294', v); }
+    set [ID(4294967295)](v) { super.m('4294967295', v); }
   }
+  assertSetterDescriptor(Derived.prototype, "a");
+  assertSetterDescriptor(Derived.prototype, "b");
+  assertSetterDescriptor(Derived.prototype, 0);
+  assertSetterDescriptor(Derived.prototype, 1);
+  assertSetterDescriptor(Derived.prototype, 2147483649);
+  assertSetterDescriptor(Derived.prototype, 4294967294);
+  assertSetterDescriptor(Derived.prototype, 4294967295);
+
   new Derived().a = 2;
   assertEquals('a 2', value);
   new Derived().b = 3;
@@ -72,4 +158,10 @@ function ID(x) {
   assertEquals('0 4', value);
   new Derived()[1] = 5;
   assertEquals('1 5', value);
+  new Derived()[2147483649] = 6;
+  assertEquals('2147483649 6', value);
+  new Derived()[4294967294] = 7;
+  assertEquals('4294967294 7', value);
+  new Derived()[4294967295] = 8;
+  assertEquals('4294967295 8', value);
 })();

test/mjsunit/es6/classes.js

@@ -195,6 +195,7 @@ function assertMethodDescriptor(object, name) {
   assertTrue(descr.writable);
   assertEquals('function', typeof descr.value);
   assertFalse('prototype' in descr.value);
+  assertEquals(name, descr.value.name);
 }
 
 
@@ -205,6 +206,7 @@ function assertGetterDescriptor(object, name) {
   assertEquals('function', typeof descr.get);
   assertFalse('prototype' in descr.get);
   assertEquals(undefined, descr.set);
+  assertEquals("get " + name, descr.get.name);
 }
 
 
@@ -215,6 +217,7 @@ function assertSetterDescriptor(object, name) {
   assertEquals(undefined, descr.get);
   assertEquals('function', typeof descr.set);
   assertFalse('prototype' in descr.set);
+  assertEquals("set " + name, descr.set.name);
 }
 
 
@@ -226,6 +229,8 @@ function assertAccessorDescriptor(object, name) {
   assertEquals('function', typeof descr.set);
   assertFalse('prototype' in descr.get);
   assertFalse('prototype' in descr.set);
+  assertEquals("get " + name, descr.get.name);
+  assertEquals("set " + name, descr.set.name);
 }
 
 
@@ -590,15 +595,38 @@ function assertAccessorDescriptor(object, name) {
     static 4() { return 4; }
     static get 5() { return 5; }
     static set 6(_) {}
+
+    2147483649() { return 2147483649; }
+    get 2147483650() { return 2147483650; }
+    set 2147483651(_) {}
+
+    static 2147483652() { return 2147483652; }
+    static get 2147483653() { return 2147483653; }
+    static set 2147483654(_) {}
+
+    4294967294() { return 4294967294; }
+    4294967295() { return 4294967295; }
+    static 4294967294() { return 4294967294; }
+    static 4294967295() { return 4294967295; }
   }
 
   assertMethodDescriptor(B.prototype, '1');
   assertGetterDescriptor(B.prototype, '2');
   assertSetterDescriptor(B.prototype, '3');
+  assertMethodDescriptor(B.prototype, '2147483649');
+  assertGetterDescriptor(B.prototype, '2147483650');
+  assertSetterDescriptor(B.prototype, '2147483651');
+  assertMethodDescriptor(B.prototype, '4294967294');
+  assertMethodDescriptor(B.prototype, '4294967295');
 
   assertMethodDescriptor(B, '4');
   assertGetterDescriptor(B, '5');
   assertSetterDescriptor(B, '6');
+  assertMethodDescriptor(B, '2147483652');
+  assertGetterDescriptor(B, '2147483653');
+  assertSetterDescriptor(B, '2147483654');
+  assertMethodDescriptor(B, '4294967294');
+  assertMethodDescriptor(B, '4294967295');
 
   class C extends B {
     1() { return super[1](); }
@@ -606,12 +634,23 @@ function assertAccessorDescriptor(object, name) {
 
     static 4() { return super[4](); }
     static get 5() { return super[5]; }
+
+    2147483649() { return super[2147483649](); }
+    get 2147483650() { return super[2147483650]; }
+
+    static 2147483652() { return super[2147483652](); }
+    static get 2147483653() { return super[2147483653]; }
+
   }
 
   assertEquals(1, new C()[1]());
   assertEquals(2, new C()[2]);
+  assertEquals(2147483649, new C()[2147483649]());
+  assertEquals(2147483650, new C()[2147483650]);
   assertEquals(4, C[4]());
   assertEquals(5, C[5]);
+  assertEquals(2147483652, C[2147483652]());
+  assertEquals(2147483653, C[2147483653]);
 })();
 
 

test/mjsunit/regress/regress-crbug-783902.js

+// Copyright 2017 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.
+
+class A {}
+
+class B extends A {
+  *gf() {
+    yield super.f();
+  }
+}

tools/v8heapconst.py

@@ -199,58 +199,58 @@ KNOWN_MAPS = {
   0x02cf1: (171, "BlockContextMap"),
   0x02d41: (171, "CatchContextMap"),
   0x02d91: (171, "WithContextMap"),
-  0x02de1: (148, "FixedDoubleArrayMap"),
-  0x02e31: (134, "MutableHeapNumberMap"),
-  0x02e81: (172, "OrderedHashTableMap"),
-  0x02ed1: (172, "NameDictionaryMap"),
-  0x02f21: (172, "GlobalDictionaryMap"),
-  0x02f71: (172, "NumberDictionaryMap"),
-  0x02fc1: (171, "SloppyArgumentsElementsMap"),
-  0x03011: (180, "SmallOrderedHashMapMap"),
-  0x03061: (181, "SmallOrderedHashSetMap"),
-  0x030b1: (189, "JSMessageObjectMap"),
-  0x03101: (137, "BytecodeArrayMap"),
-  0x03151: (171, "ModuleInfoMap"),
-  0x031a1: (177, "NoClosuresCellMap"),
-  0x031f1: (177, "OneClosureCellMap"),
-  0x03241: (177, "ManyClosuresCellMap"),
-  0x03291: (175, "PropertyArrayMap"),
-  0x032e1: (130, "BigIntMap"),
-  0x03331: (64, "StringMap"),
-  0x03381: (73, "ConsOneByteStringMap"),
-  0x033d1: (65, "ConsStringMap"),
-  0x03421: (77, "ThinOneByteStringMap"),
-  0x03471: (69, "ThinStringMap"),
-  0x034c1: (67, "SlicedStringMap"),
-  0x03511: (75, "SlicedOneByteStringMap"),
-  0x03561: (66, "ExternalStringMap"),
-  0x035b1: (82, "ExternalStringWithOneByteDataMap"),
-  0x03601: (74, "ExternalOneByteStringMap"),
-  0x03651: (98, "ShortExternalStringMap"),
-  0x036a1: (114, "ShortExternalStringWithOneByteDataMap"),
-  0x036f1: (0, "InternalizedStringMap"),
-  0x03741: (2, "ExternalInternalizedStringMap"),
-  0x03791: (18, "ExternalInternalizedStringWithOneByteDataMap"),
-  0x037e1: (10, "ExternalOneByteInternalizedStringMap"),
-  0x03831: (34, "ShortExternalInternalizedStringMap"),
-  0x03881: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
-  0x038d1: (42, "ShortExternalOneByteInternalizedStringMap"),
-  0x03921: (106, "ShortExternalOneByteStringMap"),
-  0x03971: (140, "FixedUint8ArrayMap"),
-  0x039c1: (139, "FixedInt8ArrayMap"),
-  0x03a11: (142, "FixedUint16ArrayMap"),
-  0x03a61: (141, "FixedInt16ArrayMap"),
-  0x03ab1: (144, "FixedUint32ArrayMap"),
-  0x03b01: (143, "FixedInt32ArrayMap"),
-  0x03b51: (145, "FixedFloat32ArrayMap"),
-  0x03ba1: (146, "FixedFloat64ArrayMap"),
-  0x03bf1: (147, "FixedUint8ClampedArrayMap"),
-  0x03c41: (158, "ScriptMap"),
-  0x03c91: (182, "CodeDataContainerMap"),
-  0x03ce1: (173, "FeedbackVectorMap"),
-  0x03d31: (171, "DebugEvaluateContextMap"),
-  0x03d81: (171, "ScriptContextTableMap"),
-  0x03dd1: (171, "DescriptorArrayMap"),
+  0x02de1: (171, "DescriptorArrayMap"),
+  0x02e31: (148, "FixedDoubleArrayMap"),
+  0x02e81: (134, "MutableHeapNumberMap"),
+  0x02ed1: (172, "OrderedHashTableMap"),
+  0x02f21: (172, "NameDictionaryMap"),
+  0x02f71: (172, "GlobalDictionaryMap"),
+  0x02fc1: (172, "NumberDictionaryMap"),
+  0x03011: (171, "SloppyArgumentsElementsMap"),
+  0x03061: (180, "SmallOrderedHashMapMap"),
+  0x030b1: (181, "SmallOrderedHashSetMap"),
+  0x03101: (189, "JSMessageObjectMap"),
+  0x03151: (137, "BytecodeArrayMap"),
+  0x031a1: (171, "ModuleInfoMap"),
+  0x031f1: (177, "NoClosuresCellMap"),
+  0x03241: (177, "OneClosureCellMap"),
+  0x03291: (177, "ManyClosuresCellMap"),
+  0x032e1: (175, "PropertyArrayMap"),
+  0x03331: (130, "BigIntMap"),
+  0x03381: (64, "StringMap"),
+  0x033d1: (73, "ConsOneByteStringMap"),
+  0x03421: (65, "ConsStringMap"),
+  0x03471: (77, "ThinOneByteStringMap"),
+  0x034c1: (69, "ThinStringMap"),
+  0x03511: (67, "SlicedStringMap"),
+  0x03561: (75, "SlicedOneByteStringMap"),
+  0x035b1: (66, "ExternalStringMap"),
+  0x03601: (82, "ExternalStringWithOneByteDataMap"),
+  0x03651: (74, "ExternalOneByteStringMap"),
+  0x036a1: (98, "ShortExternalStringMap"),
+  0x036f1: (114, "ShortExternalStringWithOneByteDataMap"),
+  0x03741: (0, "InternalizedStringMap"),
+  0x03791: (2, "ExternalInternalizedStringMap"),
+  0x037e1: (18, "ExternalInternalizedStringWithOneByteDataMap"),
+  0x03831: (10, "ExternalOneByteInternalizedStringMap"),
+  0x03881: (34, "ShortExternalInternalizedStringMap"),
+  0x038d1: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
+  0x03921: (42, "ShortExternalOneByteInternalizedStringMap"),
+  0x03971: (106, "ShortExternalOneByteStringMap"),
+  0x039c1: (140, "FixedUint8ArrayMap"),
+  0x03a11: (139, "FixedInt8ArrayMap"),
+  0x03a61: (142, "FixedUint16ArrayMap"),
+  0x03ab1: (141, "FixedInt16ArrayMap"),
+  0x03b01: (144, "FixedUint32ArrayMap"),
+  0x03b51: (143, "FixedInt32ArrayMap"),
+  0x03ba1: (145, "FixedFloat32ArrayMap"),
+  0x03bf1: (146, "FixedFloat64ArrayMap"),
+  0x03c41: (147, "FixedUint8ClampedArrayMap"),
+  0x03c91: (158, "ScriptMap"),
+  0x03ce1: (182, "CodeDataContainerMap"),
+  0x03d31: (173, "FeedbackVectorMap"),
+  0x03d81: (171, "DebugEvaluateContextMap"),
+  0x03dd1: (171, "ScriptContextTableMap"),
   0x03e21: (192, "ExternalMap"),
   0x03e71: (106, "NativeSourceStringMap"),
   0x03ec1: (165, "Tuple2Map"),