Revert "Revert "Use Kernel frontend from run_vm_tests.""

runtime/vm/unit_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/unit_test.h"
 
 #include <stdio.h>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
@@ skipping 10 matching lines @@
 #include "vm/parser.h"
 #include "vm/symbols.h"
 #include "vm/thread.h"
 #include "vm/virtual_memory.h"
 
 using dart::bin::Builtin;
 using dart::bin::DartUtils;
 
 namespace dart {
 
+DECLARE_FLAG(bool, use_dart_frontend);
+
 TestCaseBase* TestCaseBase::first_ = NULL;
 TestCaseBase* TestCaseBase::tail_ = NULL;
 
 
 TestCaseBase::TestCaseBase(const char* name)
     : raw_test_(false), next_(NULL), name_(name) {
   if (first_ == NULL) {
     first_ = this;
   } else {
     tail_->next_ = this;
@@ skipping 210 matching lines @@
   Dart_Handle source = DartUtils::ReadStringFromFile(resolved_url_chars);
   EXPECT_VALID(source);
   if (tag == Dart_kImportTag) {
     return Dart_LoadLibrary(url, resolved_url, source, 0, 0);
   } else {
     ASSERT(tag == Dart_kSourceTag);
     return Dart_LoadSource(library, url, resolved_url, source, 0, 0);
   }
 }
 
-
-Dart_Handle TestCase::LoadTestScript(const char* script,
-                                     Dart_NativeEntryResolver resolver,
-                                     const char* lib_url,
-                                     bool finalize_classes) {
+static Dart_Handle LoadTestScriptWithVMParser(const char* script,
+                                              Dart_NativeEntryResolver resolver,
+                                              const char* lib_url,
+                                              bool finalize_classes) {
   Dart_Handle url = NewString(lib_url);
   Dart_Handle source = NewString(script);
   Dart_Handle result = Dart_SetLibraryTagHandler(LibraryTagHandler);
   EXPECT_VALID(result);
   Dart_Handle lib = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
   DART_CHECK_VALID(lib);
   result = Dart_SetNativeResolver(lib, resolver, NULL);
   DART_CHECK_VALID(result);
   if (finalize_classes) {
     result = Dart_FinalizeLoading(false);
     DART_CHECK_VALID(result);
   }
   return lib;
 }
 
+Dart_Handle TestCase::LoadTestScript(const char* script,
+                                     Dart_NativeEntryResolver resolver,
+                                     const char* lib_url,
+                                     bool finalize_classes) {
+  if (!FLAG_use_dart_frontend) {
+    return LoadTestScriptWithVMParser(script, resolver, lib_url,
+                                      finalize_classes);
+  }
+
+  Zone* zone = Thread::Current()->zone();
+  char* filename = OS::SCreate(zone, "file:///%s", lib_url);
+  // clang-format off
+  Dart_SourceFile sourcefiles[] = {
+    {
+      filename, script,
+    },
+    {
+      "file:///.packages", "untitled:/"
+    }};
+  // clang-format on
+
+  int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
+  Dart_KernelCompilationResult compilation_result =
+      Dart_CompileSourcesToKernel(filename, sourcefiles_count, sourcefiles);
+
+  if (compilation_result.status != Dart_KernelCompilationStatus_Ok) {
+    return Dart_NewApiError(OS::SCreate(Thread::Current()->zone(),
+                                        "Compilation failed %s",
+                                        compilation_result.error));
+  }
+  const uint8_t* kernel_file = compilation_result.kernel;
+  intptr_t kernel_length = compilation_result.kernel_size;
+  if (kernel_file == NULL) {
+    return Dart_NewApiError(OS::SCreate(
+        Thread::Current()->zone(), "front end generated a NULL kernel file"));
+  }
+  void* kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
+  if (kernel_program == NULL) {
+    return Dart_NewApiError(OS::SCreate(
+        Thread::Current()->zone(), "Failed to read generated kernel binary"));
+  }
+  return Dart_LoadKernel(kernel_program);
+}
 
 #ifndef PRODUCT
 
 
 void TestCase::SetReloadTestScript(const char* script) {
   if (script_reload_key == kUnsetThreadLocalKey) {
     script_reload_key = OSThread::CreateThreadLocal();
   }
   ASSERT(script_reload_key != kUnsetThreadLocalKey);
   ASSERT(OSThread::GetThreadLocal(script_reload_key) == 0);
@@ skipping 201 matching lines @@
   }
   // Copy the remainder of in to out.
   while (*in != '\0') {
     *out++ = *in++;
   }
   *out = '\0';
 }
 
 
 }  // namespace dart