Revert of [Interpreter] Add CreateClosure to BytecodeGraphBuilder.

test/unittests/compiler/bytecode-graph-builder-unittest.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 <iostream>
 
 #include "src/compiler/bytecode-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/instruction.h"
@@ skipping 22 matching lines @@
   Handle<TypeFeedbackMetadata> vector_metadata =
       TypeFeedbackMetadata::New(isolate, spec);
   return TypeFeedbackVector::New(isolate, vector_metadata);
 }
 
 
 class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
  public:
   BytecodeGraphBuilderTest() {}
 
-  std::pair<Graph*, Handle<SharedFunctionInfo>> GetCompletedGraphAndSharedInfo(
-      Handle<BytecodeArray> bytecode_array,
-      MaybeHandle<TypeFeedbackVector> feedback_vector =
-          MaybeHandle<TypeFeedbackVector>(),
-      LanguageMode language_mode = LanguageMode::SLOPPY);
-
   Graph* GetCompletedGraph(Handle<BytecodeArray> bytecode_array,
                            MaybeHandle<TypeFeedbackVector> feedback_vector =
                                MaybeHandle<TypeFeedbackVector>(),
                            LanguageMode language_mode = LanguageMode::SLOPPY);
 
   Matcher<Node*> IsUndefinedConstant();
   Matcher<Node*> IsNullConstant();
   Matcher<Node*> IsTheHoleConstant();
   Matcher<Node*> IsFalseConstant();
   Matcher<Node*> IsTrueConstant();
   Matcher<Node*> IsIntPtrConstant(int value);
   Matcher<Node*> IsFeedbackVector(Node* effect, Node* control);
 
   static Handle<String> GetName(Isolate* isolate, const char* name) {
     Handle<String> result = isolate->factory()->NewStringFromAsciiChecked(name);
     return isolate->factory()->string_table()->LookupString(isolate, result);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BytecodeGraphBuilderTest);
 };
 
 
-std::pair<Graph*, Handle<SharedFunctionInfo>>
-BytecodeGraphBuilderTest::GetCompletedGraphAndSharedInfo(
+Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
     Handle<BytecodeArray> bytecode_array,
     MaybeHandle<TypeFeedbackVector> feedback_vector,
     LanguageMode language_mode) {
   MachineOperatorBuilder* machine = new (zone()) MachineOperatorBuilder(
       zone(), kMachPtr, InstructionSelector::SupportedMachineOperatorFlags());
   CommonOperatorBuilder* common = new (zone()) CommonOperatorBuilder(zone());
   JSOperatorBuilder* javascript = new (zone()) JSOperatorBuilder(zone());
   Graph* graph = new (zone()) Graph(zone());
   JSGraph* jsgraph = new (zone())
       JSGraph(isolate(), graph, common, javascript, nullptr, machine);
 
   Handle<String> name = factory()->NewStringFromStaticChars("test");
   Handle<String> script = factory()->NewStringFromStaticChars("test() {}");
   Handle<SharedFunctionInfo> shared_info =
       factory()->NewSharedFunctionInfo(name, MaybeHandle<Code>());
   shared_info->set_script(*factory()->NewScript(script));
   if (!feedback_vector.is_null()) {
     shared_info->set_feedback_vector(*feedback_vector.ToHandleChecked());
   }
 
   ParseInfo parse_info(zone(), shared_info);
   parse_info.set_language_mode(language_mode);
   CompilationInfo info(&parse_info);
   info.shared_info()->set_function_data(*bytecode_array);
 
   BytecodeGraphBuilder graph_builder(zone(), &info, jsgraph);
   graph_builder.CreateGraph();
-  return std::make_pair(graph_builder.graph(), shared_info);
+  return graph;
 }
 
 
-Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
-    Handle<BytecodeArray> bytecode_array,
-    MaybeHandle<TypeFeedbackVector> feedback_vector,
-    LanguageMode language_mode) {
-  return GetCompletedGraphAndSharedInfo(bytecode_array, feedback_vector,
-                                        language_mode)
-      .first;
-}
-
-
 Matcher<Node*> BytecodeGraphBuilderTest::IsUndefinedConstant() {
   return IsHeapConstant(factory()->undefined_value());
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsNullConstant() {
   return IsHeapConstant(factory()->null_value());
 }
 
 
@@ skipping 692 matching lines @@
   construct_inputs.push_back(IsParameter(1));
   construct_inputs.push_back(IsParameter(2));
   construct_inputs.push_back(IsParameter(3));
   construct_inputs.push_back(IsParameter(4));
   construct_inputs.push_back(IsParameter(1));
   Matcher<Node*> call_construct =
       IsJSCallConstruct(construct_inputs, start, start);
   EXPECT_THAT(ret, IsReturn(call_construct, call_construct, IsIfSuccess(_)));
 }
 
-
-TEST_F(BytecodeGraphBuilderTest, CreateClosure) {
-  PretenureFlag kPretenureFlags[] = {NOT_TENURED, TENURED};
-  TRACED_FOREACH(PretenureFlag, pretenure_flag, kPretenureFlags) {
-    interpreter::BytecodeArrayBuilder inner_builder(isolate(), zone());
-    inner_builder.set_locals_count(0);
-    inner_builder.set_context_count(0);
-    inner_builder.set_parameter_count(3);
-    inner_builder.LoadAccumulatorWithRegister(inner_builder.Parameter(2))
-        .BinaryOperation(Token::Value::ADD, inner_builder.Parameter(1),
-                         Strength::WEAK)
-        .Return();
-
-    std::pair<Graph*, Handle<SharedFunctionInfo>> inner_graph_and_shared_info =
-        GetCompletedGraphAndSharedInfo(inner_builder.ToBytecodeArray());
-    Handle<SharedFunctionInfo> shared_info = inner_graph_and_shared_info.second;
-
-    interpreter::BytecodeArrayBuilder builder(isolate(), zone());
-    builder.set_locals_count(4);
-    builder.set_context_count(0);
-    builder.set_parameter_count(3);
-    builder.CreateClosure(shared_info, pretenure_flag).Return();
-
-    Graph* graph = GetCompletedGraph(builder.ToBytecodeArray());
-    Node* start = graph->start();
-    Node* ret = graph->end()->InputAt(0);
-
-    Matcher<Node*> create_closure =
-        IsCreateClosure(shared_info, pretenure_flag, start, start);
-    EXPECT_THAT(ret, IsReturn(create_closure, create_closure, start));
-  }
-}
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8