[Interpreter] Add function literal support.

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 103 matching lines @@
       CcTest::i_isolate()->factory()->NewStringFromAsciiChecked(expected);
   CHECK(String::cast(actual)->Equals(*expected_string));
 }
 
 
 static void CheckConstant(Handle<Object> expected, Object* actual) {
   CHECK(actual == *expected || expected->StrictEquals(actual));
 }
 
 
+static void CheckConstant(InstanceType expected, Object* actual) {

[Michael Starzinger, 2015/10/09 13:19:00]

nit: How would you feel about s/CheckConstant/CheckInstanceType/ here?

[rmcilroy, 2015/10/12 17:00:15]

This would require rewriting the CheckBytecodeArrayEqual function since it
currently uses the template to work out which CheckConstant operator to call
based on the type of the constants used in the ExpectedSnippet. This was a way
of checking that the constants were the expected types since we can't check
their values for these tests. Would you be OK landing it as-is?  

[Michael Starzinger, 2015/10/13 07:56:14]

Acknowledged. Yep, fine with me.

+  CHECK_EQ(expected, HeapObject::cast(actual)->map()->instance_type());
+}
+
+
 template <typename T>
 static void CheckBytecodeArrayEqual(struct ExpectedSnippet<T> expected,
                                     Handle<BytecodeArray> actual,
                                     bool has_unknown = false) {
   CHECK_EQ(actual->frame_size(), expected.frame_size);
   CHECK_EQ(actual->parameter_count(), expected.parameter_count);
   CHECK_EQ(actual->length(), expected.bytecode_length);
   if (expected.constant_count != -1) {
     if (expected.constant_count == 0) {
       CHECK_EQ(actual->constant_pool(), CcTest::heap()->empty_fixed_array());
@@ skipping 1603 matching lines @@
   };
 
   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(FunctionLiterals) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  ExpectedSnippet<InstanceType> snippets[] = {
+      {"return function(){ }",
+       0,
+       1,
+       5,
+       {
+           B(LdaConstant), U8(0),    //
+           B(CreateClosure), U8(0),  //
+           B(Return)                 //
+       },
+       1,
+       {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+      {"return (function(){ })()",
+       2 * kPointerSize,
+       1,
+       14,
+       {
+           B(LdaConstant), U8(0),       //
+           B(CreateClosure), U8(0),     //
+           B(Star), R(0),               //
+           B(LdaUndefined),             //
+           B(Star), R(1),               //
+           B(Call), R(0), R(1), U8(0),  //
+           B(Return)                    //
+       },
+       1,
+       {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+      {"return (function(x){ return x; })(1)",
+       3 * kPointerSize,
+       1,
+       18,
+       {
+           B(LdaConstant), U8(0),       //
+           B(CreateClosure), U8(0),     //
+           B(Star), R(0),               //
+           B(LdaUndefined),             //
+           B(Star), R(1),               //
+           B(LdaSmi8), U8(1),           //
+           B(Star), R(2),               //
+           B(Call), R(0), R(1), U8(1),  //
+           B(Return)                    //
+       },
+       1,
+       {InstanceType::SHARED_FUNCTION_INFO_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