Add support for compiling Dart via the FE in dart2js.

tests/compiler/dart2js/kernel/compiler_helper.dart

 // Copyright (c) 2017, 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.
 
 // Partial test that the closed world computed from [WorldImpact]s derived from
 // kernel is equivalent to the original computed from resolution.
 library dart2js.kernel.compiler_helper;
 
 import 'dart:async';
 import 'dart:io';
@@ skipping 35 matching lines @@
   };
   for (String source in sources) {
     String name = 'input${memorySourceFiles.length}.dart';
     Uri uri = Uri.parse('memory:$name');
     memorySourceFiles[name] = source;
     uris.add(uri);
   }
   Compiler compiler = compilerFor(
       entryPoint: entryPoint,
       memorySourceFiles: memorySourceFiles,
-      options: [Flags.analyzeAll, Flags.useKernel, Flags.enableAssertMessage]);
+      options: [
+        Flags.analyzeAll,
+        Flags.useKernelInSsa,
+        Flags.enableAssertMessage
+      ]);
   compiler.librariesToAnalyzeWhenRun = uris;
   await compiler.run(entryPoint);
 
   List<CompileFunction> compilers = <CompileFunction>[];
   for (Uri uri in uris) {
     compilers.add(() async {
       Compiler compiler2 = compilerFor(
           entryPoint: uri,
           memorySourceFiles: memorySourceFiles,
           options: [
             Flags.analyzeOnly,
             Flags.enableAssertMessage,
-            Flags.loadFromDill
+            Flags.useKernel
           ]);
       ElementResolutionWorldBuilder.useInstantiationMap = true;
       compiler2.resolution.retainCachesForTesting = true;
       KernelFrontEndStrategy frontendStrategy = compiler2.frontendStrategy;
       KernelToElementMapForImpact elementMap = frontendStrategy.elementMap;
       ir.Program program = new ir.Program(
           libraries:
               compiler.backend.kernelTask.kernel.libraryDependencies(uri));
       LibraryElement library = compiler.libraryLoader.lookupLibrary(uri);
       Expect.isNotNull(library, 'No library found for $uri');
       program.mainMethod = compiler.backend.kernelTask.kernel
           .functionToIr(library.findExported(Identifiers.main));
-      compiler2.libraryLoader = new MemoryDillLibraryLoaderTask(
+      compiler2.libraryLoader = new MemoryKernelLibraryLoaderTask(
           elementMap, compiler2.reporter, compiler2.measurer, program);
       await compiler2.run(uri);
       return compiler2;
     });
   }
   return compilers;
 }
 
 /// Analyze [memorySourceFiles] with [entryPoint] as entry-point using the
 /// kernel based element model. The returned [Pair] contains the compiler used
 /// to create the IR and the kernel based compiler.
 Future<Pair<Compiler, Compiler>> analyzeOnly(
     Uri entryPoint, Map<String, String> memorySourceFiles,
     {bool printSteps: false}) async {
   if (printSteps) {
     print('---- analyze-all -------------------------------------------------');
   }
   Compiler compiler = compilerFor(
       entryPoint: entryPoint,
       memorySourceFiles: memorySourceFiles,
-      options: [Flags.analyzeAll, Flags.useKernel, Flags.enableAssertMessage]);
+      options: [
+        Flags.analyzeAll,
+        Flags.useKernelInSsa,
+        Flags.enableAssertMessage
+      ]);
   await compiler.run(entryPoint);
 
   if (printSteps) {
     print('---- closed world from kernel ------------------------------------');
   }
   Compiler compiler2 = compilerFor(
       entryPoint: entryPoint,
       memorySourceFiles: memorySourceFiles,
-      options: [
-        Flags.analyzeOnly,
-        Flags.enableAssertMessage,
-        Flags.loadFromDill
-      ]);
+      options: [Flags.analyzeOnly, Flags.enableAssertMessage, Flags.useKernel]);
   ElementResolutionWorldBuilder.useInstantiationMap = true;
   compiler2.resolution.retainCachesForTesting = true;
   KernelFrontEndStrategy frontendStrategy = compiler2.frontendStrategy;
   KernelToElementMapForImpact elementMap = frontendStrategy.elementMap;
-  compiler2.libraryLoader = new MemoryDillLibraryLoaderTask(
+  compiler2.libraryLoader = new MemoryKernelLibraryLoaderTask(
       elementMap,
       compiler2.reporter,
       compiler2.measurer,
       compiler.backend.kernelTask.program);
   await compiler2.run(entryPoint);
   return new Pair<Compiler, Compiler>(compiler, compiler2);
 }
 
-class MemoryDillLibraryLoaderTask extends DillLibraryLoaderTask {
+class MemoryKernelLibraryLoaderTask extends KernelLibraryLoaderTask {
   final ir.Program program;
 
-  MemoryDillLibraryLoaderTask(KernelToElementMapForImpact elementMap,
+  MemoryKernelLibraryLoaderTask(KernelToElementMapForImpact elementMap,
       DiagnosticReporter reporter, Measurer measurer, this.program)
-      : super(elementMap, null, null, reporter, measurer);
+      : super(elementMap, null, reporter, measurer);
 
   Future<LoadedLibraries> loadLibrary(Uri resolvedUri,
       {bool skipFileWithPartOfTag: false}) async {
     return createLoadedLibraries(program);
   }
 }
 
 Future createTemp(Uri entryPoint, Map<String, String> memorySourceFiles,
     {bool printSteps: false}) async {
   if (memorySourceFiles.isNotEmpty) {
@@ skipping 35 matching lines @@
     CompilerOutput compilerOutput,
     void beforeRun(Compiler compiler)}) async {
   Uri dillFile =
       await generateDill(entryPoint, memorySourceFiles, printSteps: printSteps);
 
   if (printSteps) {
     print('---- compile from dill $dillFile ---------------------------------');
   }
   Compiler compiler = compilerFor(
       entryPoint: dillFile,
-      options: [Flags.loadFromDill]..addAll(options),
+      options: [Flags.useKernel]..addAll(options),
       outputProvider: compilerOutput);
   ElementResolutionWorldBuilder.useInstantiationMap = true;
   compiler.resolution.retainCachesForTesting = true;
   if (beforeRun != null) {
     beforeRun(compiler);
   }
   await compiler.run(dillFile);
   return compiler;
 }