Reapply "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 194 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) {
+    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 195 matching lines @@
         // this until after the resolution queue is processed.
         deferredLoadTask.beforeResolution(this);
         impactStrategy = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
         resolutionEnqueuer.applyImpact(mainImpact);
         if (options.resolveOnly) {
-          libraryLoader.libraries.where((LibraryElement library) {
+          libraryLoader.libraries.where((LibraryEntity library) {
             return !serialization.isDeserialized(library);
-          }).forEach((LibraryElement library) {
-            reporter.log('Enqueuing ${library.canonicalUri}');
+          }).forEach((LibraryEntity library) {
+            reporter
+                .log('Enqueuing ${(library as LibraryElement).canonicalUri}');
             resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (analyzeAll) {
-          libraryLoader.libraries.forEach((LibraryElement library) {
-            reporter.log('Enqueuing ${library.canonicalUri}');
+          libraryLoader.libraries.forEach((LibraryEntity library) {
+            reporter
+                .log('Enqueuing ${(library as LibraryElement).canonicalUri}');
             resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (options.analyzeMain) {
           if (mainApp != null) {
             resolutionEnqueuer.applyImpact(computeImpactForLibrary(mainApp));
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
               resolutionEnqueuer.applyImpact(computeImpactForLibrary(
                   libraryLoader.lookupLibrary(libraryUri)));
@@ skipping 24 matching lines @@
               .enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
             return;
           }
         }
 
         if (options.resolveOnly && !compilationFailed) {
           reporter.log('Serializing to ${options.resolutionOutput}');
           serialization.serializeToSink(
               userOutputProvider.createOutputSink(
                   '', 'data', api.OutputType.serializationData),
-              libraryLoader.libraries.where((LibraryElement library) {
+              libraryLoader.libraries.where((LibraryEntity library) {
             return !serialization.isDeserialized(library);
           }));
         }
         if (options.analyzeOnly) {
           if (!analyzeAll && !compilationFailed) {
             // No point in reporting unused code when [analyzeAll] is true: all
             // code is artificially used.
             // If compilation failed, it is possible that the error prevents the
             // compiler from analyzing all the code.
             // TODO(johnniwinther): Reenable this when the reporting is more
@@ skipping 16 matching lines @@
         backend.onTypeInferenceComplete(globalInference.results);
 
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
 
         Enqueuer codegenEnqueuer = enqueuer.createCodegenEnqueuer(closedWorld);
         _codegenWorldBuilder = codegenEnqueuer.worldBuilder;
         codegenEnqueuer.applyImpact(
             backend.onCodegenStart(closedWorld, _codegenWorldBuilder));
         if (compileAll) {
-          libraryLoader.libraries.forEach((LibraryElement library) {
+          libraryLoader.libraries.forEach((LibraryEntity library) {
             codegenEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         }
         processQueue(codegenEnqueuer, mainMethod, libraryLoader.libraries,
             onProgress: showCodegenProgress);
         codegenEnqueuer.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram(closedWorld);
 
         if (options.dumpInfo) {
@@ skipping 256 matching lines @@
           member.forEachLocalMember(checkLive);
         }
       } else if (member.isTypedef) {
         if (!member.isResolved) {
           reporter.reportHintMessage(
               member, MessageKind.UNUSED_TYPEDEF, {'name': member.name});
         }
       }
     }
 
-    libraryLoader.libraries.forEach((LibraryElement library) {
+    libraryLoader.libraries.forEach((LibraryEntity entity) {
       // TODO(ahe): Implement better heuristics to discover entry points of
       // packages and use that to discover unused implementation details in
       // packages.
+      LibraryElement library = entity;
       if (library.isPlatformLibrary || library.isPackageLibrary) return;
       library.compilationUnits.forEach((unit) {
         unit.forEachLocalMember(checkLive);
       });
     });
   }
 
   /// Helper for determining whether the current element is declared within
   /// 'user code'.
   ///
@@ skipping 985 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;
   }
 }