[Interpreter] Implement ForIn in bytecode graph builder.

src/runtime/runtime-interpreter.cc

 // Copyright 2015 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/isolate-inl.h"
 
 namespace v8 {
@@ skipping 130 matching lines @@
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 0);
   CONVERT_SMI_ARG_CHECKED(pretenured_flag, 1);
   Handle<Context> context(isolate->context(), isolate);
   return *isolate->factory()->NewFunctionFromSharedFunctionInfo(
       shared, context, static_cast<PretenureFlag>(pretenured_flag));
 }
 
 
+namespace {
+
+MaybeHandle<JSReceiver> ToObjectHelper(Object** args_object, Isolate* isolate) {
+  Object* o = Runtime_ToObject(1, args_object, isolate);
+  return MaybeHandle<JSReceiver>(handle(JSReceiver::cast(o), isolate));
+}
+
+
+MaybeHandle<Object> GetPropertyNamesFastHelper(Object** args_object,
+                                               Isolate* isolate) {
+  Object* o = Runtime_GetPropertyNamesFast(1, args_object, isolate);
+  return MaybeHandle<Object>(handle(Object::cast(o), isolate));
+}
+
+}  // namespace
+
+
 RUNTIME_FUNCTION(Runtime_InterpreterForInPrepare) {
   HandleScope scope(isolate);
-  DCHECK_EQ(2, args.length());
+  DCHECK_EQ(1, args.length());
   CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
-  CONVERT_ARG_HANDLE_CHECKED(HeapObject, property_names, 1);
 
-  Handle<Object> cache_type = property_names;
-  Handle<Map> cache_type_map = handle(property_names->map(), isolate);
+  // Initialize return triple such that cache_length is zero which'll
+  // coax ForInDone to quit on first attempt should the function
+  // return early.
+  Handle<FixedArray> result = isolate->factory()->NewFixedArray(3);
+  result->set(2, Smi::FromInt(0));
+
+  if (receiver->IsNull() || receiver->IsUndefined()) {

[rmcilroy, 2015/12/18 16:01:55]

This won't be null given you have the branch in the bytecode. Can you remove the
JumpIfNull bytecode from the generated code (I'm fine if this is a todo for a
followup CL).

[oth, 2015/12/21 10:05:53]

Done. This was stale.

+    return *result;
+  }
+
+  Handle<Object> cache_type;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, cache_type,
+      GetPropertyNamesFastHelper(Handle<Object>::cast(receiver).location(),
+                                 isolate),
+      *result);
+
   Handle<Map> receiver_map = handle(receiver->map(), isolate);
-
   Handle<FixedArray> cache_array;
   int cache_length;
-
-  if (cache_type_map.is_identical_to(isolate->factory()->meta_map())) {
+  if (cache_type->IsMap()) {
+    Handle<Map> cache_type_map =
+        handle(Handle<Map>::cast(cache_type)->map(), isolate);
+    DCHECK(cache_type_map.is_identical_to(isolate->factory()->meta_map()));
     int enum_length = cache_type_map->EnumLength();
     DescriptorArray* descriptors = receiver_map->instance_descriptors();
     if (enum_length > 0 && descriptors->HasEnumCache()) {
       cache_array = handle(descriptors->GetEnumCache(), isolate);
       cache_length = cache_array->length();
     } else {
       cache_array = isolate->factory()->empty_fixed_array();
       cache_length = 0;
     }
   } else {
     cache_array = Handle<FixedArray>::cast(cache_type);
     cache_length = cache_array->length();
 
     STATIC_ASSERT(JS_PROXY_TYPE == FIRST_JS_RECEIVER_TYPE);
     if (receiver_map->instance_type() == JS_PROXY_TYPE) {
       // Zero indicates proxy
       cache_type = Handle<Object>(Smi::FromInt(0), isolate);
     } else {
       // One entails slow check
       cache_type = Handle<Object>(Smi::FromInt(1), isolate);
     }
   }
 
-  Handle<FixedArray> result = isolate->factory()->NewFixedArray(4);
-  result->set(0, *receiver);
+  result->set(0, *cache_type);
   result->set(1, *cache_array);
-  result->set(2, *cache_type);
-  result->set(3, Smi::FromInt(cache_length));
+  result->set(2, Smi::FromInt(cache_length));
   return *result;
 }
 
 
+RUNTIME_FUNCTION(Runtime_InterpreterToObjectOrNull) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(1, args.length());
+
+  Handle<JSReceiver> receiver;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, receiver,
+                                   ToObjectHelper(args.arguments(), isolate),
+                                   isolate->heap()->null_value());
+  return *receiver;
+}
+
 }  // namespace internal
 }  // namespace v8