ES6: Add support for method shorthand in object literals

src/factory.cc

 // Copyright 2014 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/factory.h"
 
 #include "src/allocation-site-scopes.h"
 #include "src/base/bits.h"
 #include "src/conversions.h"
 #include "src/isolate-inl.h"
@@ skipping 1219 matching lines @@
                                  Handle<SharedFunctionInfo> info,
                                  Handle<Context> context) {
   function->initialize_properties();
   function->initialize_elements();
   function->set_shared(*info);
   function->set_code(info->code());
   function->set_context(*context);
   function->set_prototype_or_initial_map(*the_hole_value());
   function->set_literals_or_bindings(*empty_fixed_array());
   function->set_next_function_link(*undefined_value());
+
+  // TODO(arv): This does not look correct. We need to make sure we use
+  // a Map that has no prototype property.
   if (info->is_arrow()) function->RemovePrototype();
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
                                         Handle<SharedFunctionInfo> info,
                                         Handle<Context> context,
                                         PretenureFlag pretenure) {
   AllocationSpace space = pretenure == TENURED ? OLD_POINTER_SPACE : NEW_SPACE;
   Handle<JSFunction> result = New<JSFunction>(map, space);
@@ skipping 99 matching lines @@
   }
 
   return prototype;
 }
 
 
 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
     Handle<SharedFunctionInfo> info,
     Handle<Context> context,
     PretenureFlag pretenure) {
-  int map_index = Context::FunctionMapIndex(info->strict_mode(),
-                                            info->is_generator());
+  int map_index = Context::FunctionMapIndex(info->strict_mode(), info->kind());
   Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
   Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
 
   if (info->ic_age() != isolate()->heap()->global_ic_age()) {
     info->ResetForNewContext(isolate()->heap()->global_ic_age());
   }
 
   int index = info->SearchOptimizedCodeMap(context->native_context(),
                                            BailoutId::None());
   if (!info->bound() && index < 0) {
@@ skipping 526 matching lines @@
       isolate(),
       isolate()->heap()->AllocateFixedArrayWithFiller(
           slot_count,
           TENURED,
           *TypeFeedbackInfo::UninitializedSentinel(isolate())),
       FixedArray);
 }
 
 
 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
-    Handle<String> name, int number_of_literals, bool is_generator,
-    bool is_arrow, Handle<Code> code, Handle<ScopeInfo> scope_info,
+    Handle<String> name, int number_of_literals, FunctionKind kind,
+    Handle<Code> code, Handle<ScopeInfo> scope_info,
     Handle<FixedArray> feedback_vector) {
+  DCHECK(IsValidFunctionKind(kind));
   Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
   shared->set_scope_info(*scope_info);
   shared->set_feedback_vector(*feedback_vector);
-  shared->set_is_arrow(is_arrow);
+  shared->set_kind(kind);
   int literals_array_size = number_of_literals;
   // If the function contains object, regexp or array literals,
   // allocate extra space for a literals array prefix containing the
   // context.
   if (number_of_literals > 0) {
     literals_array_size += JSFunction::kLiteralsPrefixSize;
   }
   shared->set_num_literals(literals_array_size);
-  if (is_generator) {
+  if (IsGeneratorFunction(kind)) {
     shared->set_instance_class_name(isolate()->heap()->Generator_string());
     shared->DisableOptimization(kGenerator);
   }
   return shared;
 }
 
 
 Handle<JSMessageObject> Factory::NewJSMessageObject(
     Handle<String> type,
     Handle<JSArray> arguments,
@@ skipping 459 matching lines @@
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 
 } }  // namespace v8::internal