Add "load from .dill" file capability and run a white-box test.

pkg/compiler/lib/src/compiler.dart

 // 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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show Future;
 
 import '../compiler_new.dart' as api;
 import 'closure.dart' as closureMapping show ClosureTask;
@@ skipping 26 matching lines @@
     show
         ResolutionDartType,
         ResolutionDynamicType,
         ResolutionInterfaceType,
         Types;
 import 'enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
 import 'environment.dart';
 import 'id_generator.dart';
 import 'io/source_information.dart' show SourceInformation;
 import 'js_backend/backend.dart' show JavaScriptBackend;
+import 'kernel/world_builder.dart' show KernelWorldBuilder;
 import 'library_loader.dart'
     show
         ElementScanner,
         LibraryLoader,
         LibraryLoaderTask,
         LoadedLibraries,
         LibraryProvider,
         ScriptLoader;
 import 'mirrors_used.dart' show MirrorUsageAnalyzerTask;
 import 'null_compiler_output.dart' show NullCompilerOutput, NullSink;
@@ skipping 50 matching lines @@
    * If true, stop compilation after type inference is complete. Used for
    * debugging and testing purposes only.
    */
   bool stopAfterTypeInference = false;
 
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
+  /// Object holding the correspondence between Kernel IR and their
+  /// corresponding K/JElements. Only (currently) used when used in conjunction
+  /// with --use-kernel and --read-dill flags.
+  KernelWorldBuilder kernelWorldBuilder;
+
   ResolvedUriTranslator get resolvedUriTranslator;
 
   LibraryElement mainApp;
   MethodElement mainFunction;
 
   DiagnosticReporter get reporter => _reporter;
   ElementEnvironment get elementEnvironment => _elementEnvironment;
   CommonElements get commonElements => _commonElements;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
@@ skipping 78 matching lines @@
 
     backend = createBackend();
     enqueuer = backend.makeEnqueuer();
 
     tasks = [
       dietParser = new DietParserTask(idGenerator, backend, reporter, measurer),
       scanner = createScannerTask(),
       serialization = new SerializationTask(this),
       patchParser = new PatchParserTask(this),
       libraryLoader = new LibraryLoaderTask(
+          options.loadFromDill,
           resolvedUriTranslator,
           options.compileOnly
               ? new _NoScriptLoader(this)
               : new _ScriptLoader(this),
           new _ElementScanner(scanner),
           serialization,
           resolvePatchUri,
           patchParser,
           environment,
           reporter,
@@ skipping 116 matching lines @@
           !link.isEmpty;
           link = link.tail) {
         Uri uri = link.head;
         if (!currentCodeLocation.inSameLocation(uri)) {
           currentCodeLocation =
               options.verbose ? new UriLocation(uri) : new CodeLocation(uri);
           compactImportChain = compactImportChain.prepend(currentCodeLocation);
         }
       }
       String importChain = compactImportChain.map((CodeLocation codeLocation) {
-        return codeLocation
-            .relativize(loadedLibraries.rootLibrary.canonicalUri);
+        return codeLocation.relativize(
+            (loadedLibraries.rootLibrary as LibraryElement).canonicalUri);
       }).join(' => ');
 
       if (!importChains.contains(importChain)) {
         if (importChains.length > compactChainLimit) {
           importChains.add('...');
           return false;
         } else {
           importChains.add(importChain);
         }
       }
@@ skipping 11 matching lines @@
 
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
   ///
   /// [loadedLibraries] contains the newly loaded libraries.
   ///
   /// The method returns a [Future] allowing for the loading of additional
   /// libraries.
   LoadedLibraries processLoadedLibraries(LoadedLibraries loadedLibraries) {
-    loadedLibraries.forEachLibrary((LibraryElement library) {
+    kernelWorldBuilder = libraryLoader.worldBuilder;
+    loadedLibraries.forEachLibrary((LibraryEntity library) {
       backend.setAnnotations(library);
     });
 
     for (Uri uri in resolvedUriTranslator.disallowedLibraryUris) {
       if (loadedLibraries.containsLibrary(uri)) {
         Set<String> importChains = computeImportChainsFor(loadedLibraries, uri);
         reporter.reportInfo(
             NO_LOCATION_SPANNABLE, MessageKind.DISALLOWED_LIBRARY_IMPORT, {
           'uri': uri,
           'importChain': importChains
@@ skipping 1571 matching lines @@
     if (library != null && library.isSynthesized) {
       return null;
     }
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           library, "The library '${uri}' was not found.");
     }
     return library;
   }
 }