[Interpreter] Add support for for..in.

test/cctest/interpreter/test-bytecode-generator.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/v8.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 3475 matching lines @@
        {"a"}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
+
+TEST(ForIn) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+  Zone zone;
+
+  int simple_flags =
+      ArrayLiteral::kDisableMementos | ArrayLiteral::kShallowElements;
+  int deep_elements_flags =
+      ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+
+  FeedbackVectorSpec feedback_spec(&zone);
+  feedback_spec.AddStoreICSlot();
+  FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+  FeedbackVectorSlot slot3 = feedback_spec.AddStoreICSlot();
+  FeedbackVectorSlot slot4 = feedback_spec.AddStoreICSlot();
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+  ExpectedSnippet<InstanceType> snippets[] = {
+      {"for (var p in null) {}",
+       2 * kPointerSize,
+       1,
+       2,
+       {B(LdaUndefined), B(Return)},
+       0},
+      {"for (var p in undefined) {}",
+       2 * kPointerSize,
+       1,
+       2,
+       {B(LdaUndefined), B(Return)},
+       0},
+      {"var x = 0;\n"
+       "for (var p in [1,2,3]) { x += p; }",
+       6 * kPointerSize,
+       1,
+       58,
+       {
+           B(LdaZero),                                      //
+           B(Star), R(1),                                   //
+           B(LdaConstant), U8(0),                           //
+           B(CreateArrayLiteral), U8(0), U8(simple_flags),  //
+           B(ForInPrepare),                                 //
+           B(Star), R(3),                                   //
+           B(LdaUndefined),                                 //
+           B(TestEqualStrict), R(3),                        //
+           B(JumpIfTrue), U8(42),                           //
+           B(LdaZero),                                      //
+           B(Star), R(4),                                   //
+           B(ForInDone), R(3),                              //
+           B(JumpIfTrue), U8(35),                           //
+           B(Ldar), R(4),                                   //
+           B(ForInNext), R(3),                              //
+           B(Star), R(5),                                   //
+           B(LdaUndefined),                                 //
+           B(TestEqualStrict), R(5),                        //
+           B(JumpIfTrue), U8(16),                           //
+           B(Ldar), R(5),                                   //
+           B(Star), R(0),                                   //
+           B(Ldar), R(0),                                   //
+           B(Star), R(2),                                   //
+           B(Ldar), R(2),                                   //
+           B(Add), R(1),                                    //
+           B(Star), R(1),                                   //
+           B(LdaSmi8), U8(1),                               //
+           B(Add), R(4),                                    //
+           B(Star), R(4),                                   //
+           B(Jump), U8(-35),                                //
+           B(LdaUndefined),                                 //
+           B(Return),                                       //
+       },
+       1,
+       {InstanceType::FIXED_ARRAY_TYPE}},
+      {"var x = { 'a': 1, 'b': 2 };\n"
+       "for (x['a'] in [10, 20, 30]) {\n"
+       "  if (x['a'] == 10) continue;\n"
+       "  if (x['a'] == 20) break;\n"
+       "}",
+       5 * kPointerSize,
+       1,
+       84,
+       {
+           B(LdaConstant), U8(0),                                       //
+           B(CreateObjectLiteral), U8(0), U8(deep_elements_flags),      //
+           B(Star), R(0),                                               //
+           B(LdaConstant), U8(1),                                       //
+           B(CreateArrayLiteral), U8(1), U8(simple_flags),              //
+           B(ForInPrepare),                                             //
+           B(Star), R(1),                                               //
+           B(LdaUndefined),                                             //
+           B(TestEqualStrict), R(1),                                    //
+           B(JumpIfTrue), U8(64),                                       //
+           B(LdaZero),                                                  //
+           B(Star), R(2),                                               //
+           B(ForInDone), R(1),                                          //
+           B(JumpIfTrue), U8(57),                                       //
+           B(Ldar), R(2),                                               //
+           B(ForInNext), R(1),                                          //
+           B(Star), R(3),                                               //
+           B(LdaUndefined),                                             //
+           B(TestEqualStrict), R(3),                                    //
+           B(JumpIfTrue), U8(38),                                       //
+           B(Ldar), R(3),                                               //
+           B(Star), R(4),                                               //
+           B(StoreICSloppy), R(0), U8(2), U8(vector->GetIndex(slot4)),  //
+           B(LoadICSloppy), R(0), U8(2), U8(vector->GetIndex(slot2)),   //
+           B(Star), R(4),                                               //
+           B(LdaSmi8), U8(10),                                          //
+           B(TestEqual), R(4),                                          //
+           B(JumpIfFalse), U8(4),                                       //
+           B(Jump), U8(16),                                             //
+           B(LoadICSloppy), R(0), U8(2), U8(vector->GetIndex(slot3)),   //
+           B(Star), R(4),                                               //
+           B(LdaSmi8), U8(20),                                          //
+           B(TestEqual), R(4),                                          //
+           B(JumpIfFalse), U8(4),                                       //
+           B(Jump), U8(10),                                             //
+           B(LdaSmi8), U8(1),                                           //
+           B(Add), R(2),                                                //
+           B(Star), R(2),                                               //
+           B(Jump), U8(-57),                                            //
+           B(LdaUndefined),                                             //
+           B(Return),                                                   //
+       },
+       3,
+       {InstanceType::FIXED_ARRAY_TYPE, InstanceType::FIXED_ARRAY_TYPE,
+        InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+      {"var x = [ 10, 11, 12 ] ;\n"
+       "for (x[0] in [1,2,3]) { return x[3]; }",
+       6 * kPointerSize,
+       1,
+       67,
+       {B(LdaConstant), U8(0),                                           //
+        B(CreateArrayLiteral), U8(0), U8(simple_flags),                  //
+        B(Star), R(0),                                                   //
+        B(LdaConstant), U8(1),                                           //
+        B(CreateArrayLiteral), U8(1), U8(simple_flags),                  //
+        B(ForInPrepare),                                                 //
+        B(Star), R(1),                                                   //
+        B(LdaUndefined),                                                 //
+        B(TestEqualStrict), R(1),                                        //
+        B(JumpIfTrue), U8(47),                                           //
+        B(LdaZero),                                                      //
+        B(Star), R(2),                                                   //
+        B(ForInDone), R(1),                                              //
+        B(JumpIfTrue), U8(40),                                           //
+        B(Ldar), R(2),                                                   //
+        B(ForInNext), R(1),                                              //
+        B(Star), R(3),                                                   //
+        B(LdaUndefined),                                                 //
+        B(TestEqualStrict), R(3),                                        //
+        B(JumpIfTrue), U8(21),                                           //
+        B(Ldar), R(3),                                                   //
+        B(Star), R(4),                                                   //
+        B(LdaZero),                                                      //
+        B(Star), R(5),                                                   //
+        B(Ldar), R(4),                                                   //
+        B(KeyedStoreICSloppy), R(0), R(5), U8(vector->GetIndex(slot3)),  //
+        B(LdaSmi8), U8(3),                                               //
+        B(KeyedLoadICSloppy), R(0), U8(vector->GetIndex(slot2)),         //
+        B(Return),                                                       //
+        B(LdaSmi8), U8(1),                                               //
+        B(Add), R(2),                                                    //
+        B(Star), R(2),                                                   //
+        B(Jump), U8(-40),                                                //
+        B(LdaUndefined),                                                 //
+        B(Return)},
+       2,
+       {InstanceType::FIXED_ARRAY_TYPE, InstanceType::FIXED_ARRAY_TYPE}},
+  };
+
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    Handle<BytecodeArray> bytecode_array =
+        helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+    CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8