Include only stuff you need, part 6: Fix cctest.h.

test/cctest/compiler/function-tester.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 "test/cctest/compiler/function-tester.h"
 
 #include "src/ast/ast-numbering.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/compiler/linkage.h"
@@ skipping 80 matching lines @@
   TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate));
   MaybeHandle<Object> no_result = Call(a, b);
   CHECK(isolate->has_pending_exception());
   CHECK(try_catch.HasCaught());
   CHECK(no_result.is_null());
   isolate->OptionalRescheduleException(true);
   CHECK(!try_catch.Message().IsEmpty());
   return try_catch.Message();
 }
 
+void FunctionTester::CheckCall(Handle<Object> expected, Handle<Object> a,
+                               Handle<Object> b, Handle<Object> c,
+                               Handle<Object> d) {
+  Handle<Object> result = Call(a, b, c, d).ToHandleChecked();
+  CHECK(expected->SameValue(*result));
+}
+
+Handle<JSFunction> FunctionTester::NewFunction(const char* source) {
+  return Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Local<v8::Function>::Cast(CompileRun(source))));
+}
+
+Handle<JSObject> FunctionTester::NewObject(const char* source) {
+  return Handle<JSObject>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(CompileRun(source))));
+}
+
 Handle<String> FunctionTester::Val(const char* string) {
   return isolate->factory()->InternalizeUtf8String(string);
 }
 
 Handle<Object> FunctionTester::Val(double value) {
   return isolate->factory()->NewNumber(value);
 }
 
 Handle<Object> FunctionTester::infinity() {
   return isolate->factory()->infinity_value();
@@ skipping 12 matching lines @@
 }
 
 Handle<Object> FunctionTester::true_value() {
   return isolate->factory()->true_value();
 }
 
 Handle<Object> FunctionTester::false_value() {
   return isolate->factory()->false_value();
 }
 
+Handle<JSFunction> FunctionTester::ForMachineGraph(Graph* graph,
+                                                   int param_count) {
+  JSFunction* p = NULL;
+  {  // because of the implicit handle scope of FunctionTester.
+    FunctionTester f(graph, param_count);
+    p = *f.function;
+  }
+  return Handle<JSFunction>(p);  // allocated in outer handle scope.
+}
+
 Handle<JSFunction> FunctionTester::Compile(Handle<JSFunction> function) {
   Zone zone(function->GetIsolate()->allocator());
   ParseInfo parse_info(&zone, function);
   CompilationInfo info(&parse_info, function);
   info.MarkAsDeoptimizationEnabled();
 
   if (!FLAG_turbo_from_bytecode) {
     CHECK(Parser::ParseStatic(info.parse_info()));
   }
   info.SetOptimizing();
@@ skipping 32 matching lines @@
 
   Handle<Code> code = Pipeline::GenerateCodeForTesting(&info, graph);
   CHECK(!code.is_null());
   function->ReplaceCode(*code);
   return function;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8