Fix for issue 29819

runtime/bin/main.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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 804 matching lines @@
         exit_code);
     Platform::Exit(kErrorExitCode);
   }
   if (exit_code == 0) {
     Snapshot::GenerateAppJIT(snapshot_filename);
   }
 }
 
 static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
                                        bool is_main_isolate,
-                                       bool kernel_file_specified,
                                        const char* script_uri,
                                        const char* package_root,
                                        const char* packages_config,
                                        bool set_native_resolvers,
                                        bool isolate_run_app_snapshot,
                                        char** error,
                                        int* exit_code) {
   Dart_EnterScope();
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
   void* kernel_program = isolate_data->kernel_program;
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   CHECK_RESULT(result);
 
   // Prepare builtin and other core libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
   result = DartUtils::PrepareForScriptLoading(false, trace_loading);
   CHECK_RESULT(result);
 
-  if (kernel_file_specified) {
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  if (dfe.kernel_file_specified()) {
     ASSERT(kernel_program != NULL);
     result = Dart_LoadKernel(kernel_program);
   } else {
     if (kernel_program != NULL) {
       Dart_Handle uri = Dart_NewStringFromCString(script_uri);
       CHECK_RESULT(uri);
       Dart_Handle resolved_script_uri = DartUtils::ResolveScript(uri);
       CHECK_RESULT(resolved_script_uri);
       result =
           Dart_LoadScript(uri, resolved_script_uri,
                           reinterpret_cast<Dart_Handle>(kernel_program), 0, 0);
       CHECK_RESULT(result);
     }
   }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+
   if (set_native_resolvers) {
     // Setup the native resolver as the snapshot does not carry it.
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kIOLibrary);
   }
   if (isolate_run_app_snapshot) {
     Dart_Handle result = Loader::ReloadNativeExtensions();
     CHECK_RESULT(result);
   }
 
@@ skipping 102 matching lines @@
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   Dart_Isolate isolate = Dart_CreateIsolate(
       script_uri, main, isolate_snapshot_data, isolate_snapshot_instructions,
       flags, isolate_data, error);
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
-  return IsolateSetupHelper(isolate, false, false, script_uri, package_root,
+  return IsolateSetupHelper(isolate, false, script_uri, package_root,
                             packages_config, isolate_snapshot_data,
                             isolate_run_app_snapshot, error, exit_code);
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
 // Returns newly created Service Isolate on success, NULL on failure.
 // For now we only support the service isolate coming up from sources
 // which are compiled by the VM parser.
 static Dart_Isolate CreateAndSetupServiceIsolate(const char* script_uri,
                                                  const char* main,
@@ skipping 77 matching lines @@
                                                 const char* main,
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
                                                 int* exit_code) {
   ASSERT(script_uri != NULL);
   void* kernel_platform = NULL;
   void* kernel_program = NULL;
   AppSnapshot* app_snapshot = NULL;
-  bool kernel_file_specified = false;
 
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   if (is_main_isolate && (snapshot_deps_filename != NULL)) {
     isolate_data->set_dependencies(new MallocGrowableArray<char*>());
   }
 
 #if defined(DART_PRECOMPILED_RUNTIME)
   // AOT: All isolates start from the app snapshot.
   bool isolate_run_app_snapshot = true;
@@ skipping 23 matching lines @@
           &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
           &isolate_snapshot_data, &isolate_snapshot_instructions);
     }
   }
   if (!isolate_run_app_snapshot) {
     kernel_platform = dfe.kernel_platform();
     kernel_program = dfe.ReadScript(script_uri);
     if (kernel_program != NULL) {
       // A kernel file was specified on the command line instead of a source
       // file. Load that kernel file directly.
-      kernel_file_specified = true;
+      dfe.set_kernel_file_specified(true);
     } else if (dfe.UseDartFrontend()) {
       kernel_program = dfe.CompileAndReadScript(script_uri, error, exit_code);
       if (kernel_program == NULL) {
         return NULL;
       }
     }
     isolate_data->kernel_program = kernel_program;
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
   Dart_Isolate isolate = NULL;
   if (kernel_platform != NULL) {
     isolate = Dart_CreateIsolateFromKernel(script_uri, main, kernel_platform,
                                            flags, isolate_data, error);
   } else if (kernel_program != NULL) {
     isolate = Dart_CreateIsolateFromKernel(script_uri, main, kernel_program,
                                            flags, isolate_data, error);
   } else {
     isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
                                  isolate_snapshot_instructions, flags,
                                  isolate_data, error);
   }
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
   bool set_native_resolvers = (kernel_program || isolate_snapshot_data);
-  return IsolateSetupHelper(isolate, is_main_isolate, kernel_file_specified,
-                            script_uri, package_root, packages_config,
-                            set_native_resolvers, isolate_run_app_snapshot,
-                            error, exit_code);
+  return IsolateSetupHelper(isolate, is_main_isolate, script_uri, package_root,
+                            packages_config, set_native_resolvers,
+                            isolate_run_app_snapshot, error, exit_code);
 }
 
 #undef CHECK_RESULT
 
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           const char* package_root,
                                           const char* package_config,
                                           Dart_IsolateFlags* flags,
                                           void* data,
@@ skipping 734 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }